I2C addressing (7-bit and 10-bit) in Embedded C - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a 7-bit I2C address.

Embedded C

uint8_t address = [1]; // 7-bit I2C address

Drag options to blanks, or click blank then click option'

A0x800

B0x1FF

C0x400

D0x3C

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing an address larger than 7 bits.

The 7-bit I2C address fits in 7 bits, so 0x3C is valid. Addresses like 0x1FF exceed 7 bits.

2fill in blank

medium

Complete the code to define a 10-bit I2C address.

Embedded C

uint16_t address = [1]; // 10-bit I2C address

Drag options to blanks, or click blank then click option'

A0x3FF

B0x7F

C0x80

D0x1000

Attempts:

3 left

💡 Hint

Common Mistakes

Using values larger than 10 bits.

The 10-bit I2C address can go up to 0x3FF (1023 decimal). 0x3FF fits in 10 bits.

3fill in blank

hard

Fix the error in the code that sets a 7-bit I2C address shifted for read/write bit.

Embedded C

uint8_t address_rw = [1] << 1; // Shift 7-bit address for R/W bit

Drag options to blanks, or click blank then click option'

A0x7F

B0x3C

C0x1E

D0x78

Attempts:

3 left

💡 Hint

Common Mistakes

Shifting an already shifted address.

The 7-bit address 0x3C must be shifted left by 1 to make room for the R/W bit. Using 0x78 is already shifted and incorrect here.

4fill in blank

hard

Fill both blanks to extract the upper 2-bit and lower 8-bit parts from a 10-bit I2C address.

Embedded C

uint8_t addr_high = (address [1] 8) & 0x03; // upper 2 bits
uint8_t addr_low = address [2] 0xFF; // lower 8 bits

Drag options to blanks, or click blank then click option'

A>>

B<<

C&

D|

Attempts:

3 left

💡 Hint

Common Mistakes

Using left shift instead of right shift for upper bits.

To get the upper bits, shift right by 8 and mask with 0x03. To get lower bits, mask with 0xFF.

5fill in blank

hard

Fill all three blanks to create the 10-bit I2C address frame with R/W bit.

Embedded C

uint16_t frame = ((uint16_t)(0xF0 | ((address [1] 7) & 0x06)) [2] 8) | (address [3] 0xFF);

Drag options to blanks, or click blank then click option'

A>>

B<<

C|

D&

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up shift directions or using wrong bitwise operators.

Mask bits with AND, shift left to position, and combine with OR to form the frame.

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