Why I2C addressing (7-bit and 10-bit) in Embedded C? - Purpose & Use Cases

The Big Idea

What if you could talk to many devices on one wire without ever mixing up who's listening?

The Scenario

Imagine you have many devices connected on a single wire bus, and you need to talk to each one separately. Without a clear way to identify each device, you might try to send commands blindly or one by one, hoping the right device listens.

The Problem

Manually managing device communication without proper addressing is slow and confusing. You risk sending data to the wrong device or missing devices entirely. It's like shouting in a crowded room without knowing who should answer--lots of noise, no clear response.

The Solution

I2C addressing gives each device a unique ID using 7-bit or 10-bit addresses. This way, the master device can call out to exactly one device at a time, making communication clear and organized on the shared bus.

Before vs After

✗ Before

send_data_to_all_devices(); // no addressing, guess who listens

✓ After

send_data_to_device(address, data); // clear 7-bit or 10-bit address

What It Enables

It allows precise, reliable communication with multiple devices on the same bus without confusion or errors.

Real Life Example

Think of a smart home system where sensors and lights share one wire. Using I2C addressing, the controller can turn on just the kitchen light or read temperature from the living room sensor without mixing commands.

Key Takeaways

I2C addressing uniquely identifies devices on a shared bus.

7-bit and 10-bit addresses let you connect many devices without confusion.

This makes communication faster, clearer, and less error-prone.

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