I2C addressing (7-bit and 10-bit) in Embedded C - Deep Dive

Overview - I2C addressing (7-bit and 10-bit)

What is it?

I2C addressing is how devices on an I2C bus identify each other using unique addresses. There are two main types: 7-bit and 10-bit addressing. The 7-bit address is the most common and uses 7 bits to identify a device, while 10-bit addressing uses more bits for more devices. This system allows multiple devices to communicate on the same two-wire bus without confusion.

Why it matters

Without proper addressing, devices on the I2C bus would not know who to talk to, causing communication errors and device conflicts. I2C addressing ensures that each device can be uniquely identified and accessed, enabling reliable data exchange in embedded systems like sensors, displays, and microcontrollers. Without it, complex device networks would be impossible or very unreliable.

Where it fits

Before learning I2C addressing, you should understand basic I2C communication and how the bus works physically. After mastering addressing, you can learn about advanced I2C features like clock stretching, multi-master setups, and error handling.

Mental Model

Core Idea

I2C addressing assigns a unique number to each device so the master knows exactly who to talk to on the shared bus.

Think of it like...

Imagine a classroom where the teacher calls students by their seat numbers to ask questions. The seat number is like the I2C address, ensuring the teacher talks to the right student without confusion.

┌───────────────┐
│   I2C Bus     │
│  (SDA, SCL)   │
└──────┬────────┘
       │
┌──────┴───────┐   ┌───────────────┐
│ Device 1     │   │ Device 2      │
│ Address 0x3C │   │ Address 0x5A  │
└──────────────┘   └───────────────┘

Master sends address → only matching device responds

Build-Up - 7 Steps

1

Foundation

Basics of I2C Addressing

Concept: Introduction to how devices are identified by addresses on the I2C bus.

I2C devices use addresses to communicate. Each device has a unique 7-bit address. The master sends this address to select which device to talk to. The address is sent first, followed by read/write bits.

Result

Devices listen for their address and respond only when addressed.

Understanding that each device has a unique address is key to grasping how multiple devices share the same bus without interfering.

2

Foundation

7-bit Address Format and Usage

Concept: How the 7-bit address is structured and used in communication.

The 7-bit address is sent in the first byte, occupying bits 7 to 1. Bit 0 is the read/write bit. For example, address 0x3C means bits 7-1 are 0111100. The master sends this byte, and the device with matching address responds.

Result

The master can read from or write to the device using this address format.

Knowing the address and read/write bit layout helps in debugging and programming I2C communication.

3

Intermediate

Limitations of 7-bit Addressing

🤔Before reading on: Do you think 7-bit addressing can support more than 128 devices on one bus? Commit to yes or no.

Concept: Understanding the address space limit and why 10-bit addressing exists.

7-bit addressing allows for 128 possible addresses (0 to 127). However, some addresses are reserved for special purposes, reducing usable addresses. When many devices are needed, 7-bit addressing is insufficient.

Result

Recognizing the need for a larger address space in complex systems.

Knowing the address limit explains why 10-bit addressing was introduced for larger device networks.

4

Intermediate

10-bit Addressing Format

🤔Before reading on: Do you think 10-bit addressing sends the entire address in one byte or multiple bytes? Commit to your answer.

Concept: How 10-bit addresses are sent over the I2C bus using multiple bytes.

10-bit addressing uses two bytes. The first byte starts with a special 5-bit code '11110', followed by the two most significant bits of the address, and the read/write bit. The second byte sends the remaining 8 bits of the address. This allows addressing up to 1024 devices.

Result

Devices with 10-bit addresses can be uniquely identified beyond the 7-bit limit.

Understanding the two-byte address format clarifies how the bus handles larger address spaces without confusion.

5

Intermediate

Addressing in Embedded C Code

Concept: How to specify and use 7-bit and 10-bit addresses in embedded C programming.

In embedded C, 7-bit addresses are often shifted left by 1 to make room for the read/write bit. For 10-bit addressing, special flags or functions are used to indicate the extended address mode. Example: // 7-bit address example #define DEVICE_ADDR_7BIT 0x3C uint8_t address = DEVICE_ADDR_7BIT << 1; // Shift left for R/W bit // 10-bit addressing requires specific API support depending on hardware Master sends address using these values to communicate.

Result

Correctly formatted addresses ensure successful communication in code.

Knowing how to format addresses in code prevents common bugs related to incorrect address shifting or mode selection.

6

Advanced

How Devices Recognize 10-bit Addresses

🤔Before reading on: Do you think 10-bit devices listen to the first byte only or wait for the second byte before responding? Commit to your answer.

Concept: The process devices use to detect and respond to 10-bit addresses on the bus.

Devices monitor the first byte for the special 11110 pattern and the two MSBs of their address. If matched, they wait for the second byte to confirm the full address before responding. This two-step process avoids conflicts with 7-bit devices.

Result

Devices correctly identify when they are being addressed in 10-bit mode.

Understanding this handshake prevents confusion about why some devices might not respond if the address bytes are sent incorrectly.

7

Expert

Common Pitfalls and Hardware Variations

🤔Before reading on: Do you think all I2C hardware supports 10-bit addressing natively? Commit to yes or no.

Concept: Challenges in using 10-bit addressing due to hardware and software differences.

Not all microcontrollers or I2C hardware support 10-bit addressing natively. Some require software workarounds or do not support it at all. Additionally, some devices may misinterpret 10-bit addresses if the bus timing or protocol is not strictly followed. Careful configuration and testing are needed in production.

Result

Awareness of hardware limits helps avoid communication failures in complex systems.

Knowing hardware support limitations guides design decisions and debugging strategies in embedded projects.

Under the Hood

I2C addressing works by sending address bits serially over the SDA line synchronized with the SCL clock. The master initiates communication by sending a start condition, followed by the address bits and a read/write bit. Devices monitor the bus and compare incoming bits to their stored address. For 7-bit addressing, this is a single byte. For 10-bit addressing, the master sends a special prefix and two bytes to extend the address space. Devices respond with an acknowledge bit if the address matches, allowing the master to proceed with data transfer.

Why designed this way?

The 7-bit addressing was chosen to balance simplicity and enough device support for most applications. As embedded systems grew more complex, the need for more addresses led to 10-bit addressing. The design keeps backward compatibility by using a special prefix for 10-bit addresses, so older 7-bit devices ignore these messages. This layered approach avoids breaking existing devices while expanding capabilities.

Master Start
   │
   ▼
[Address Byte 1]
   │
   ├─7-bit: 7 address bits + R/W bit → Device matches → ACK
   │
   └─10-bit: 11110 + 2 MSBs + R/W bit → Device matches → ACK
       │
       ▼
   [Address Byte 2]
       │
       └─Remaining 8 bits of address → Device matches → ACK
       │
       ▼
   Data Transfer

Myth Busters - 4 Common Misconceptions

Quick: Does shifting a 7-bit address left by 1 always produce the correct I2C address byte? Commit to yes or no.

Common Belief: You can always shift the 7-bit address left by 1 to get the correct address byte for I2C communication.

Reality: Shifting left by 1 is correct only if the hardware or software expects the address in that format. Some APIs expect the 7-bit address without shifting and handle the read/write bit internally.

Why it matters: Incorrect shifting leads to addressing the wrong device or no response, causing communication failures that are hard to debug.

Quick: Do all I2C devices support 10-bit addressing? Commit to yes or no.

Common Belief: All I2C devices support both 7-bit and 10-bit addressing modes.

Reality: Many devices support only 7-bit addressing. 10-bit addressing is less common and not universally supported.

Why it matters: Assuming 10-bit support can cause devices to never respond, leading to wasted time and system errors.

Quick: Does the read/write bit belong to the device address? Commit to yes or no.

Common Belief: The read/write bit is part of the device's address.

Reality: The read/write bit is not part of the device address; it indicates the operation type and is appended after the address bits.

Why it matters: Confusing the read/write bit with the address can cause incorrect address calculation and communication errors.

Quick: Can 10-bit addressing be used without sending the special prefix? Commit to yes or no.

Common Belief: You can send the 10-bit address as a single continuous byte sequence without any special prefix.

Reality: 10-bit addressing requires a special prefix (11110) in the first byte to signal extended addressing; skipping this causes devices to ignore the address.

Why it matters: Missing the prefix leads to devices not recognizing their address, causing communication failure.

Expert Zone

1

Some microcontrollers require manual handling of the read/write bit in software when using 7-bit addresses, while others handle it automatically in hardware.

2

10-bit addressing can introduce timing challenges because it requires sending two address bytes, which may affect bus speed and require careful synchronization.

3

Certain reserved 7-bit addresses are used for special functions like general call or high-speed mode, and using them incorrectly can disrupt bus communication.

When NOT to use

Avoid 10-bit addressing if your hardware or devices do not support it; instead, use multiple 7-bit buses or multiplexers to expand device count. For simple systems with fewer devices, 7-bit addressing is simpler and more compatible.

Production Patterns

In production, 7-bit addressing is standard for most sensors and peripherals. 10-bit addressing is used in large sensor arrays or complex systems like industrial controllers. Developers often use device datasheets to confirm address modes and implement address scanning routines to detect devices dynamically.

Connections

Networking IP Addressing

Both assign unique addresses to devices on a shared communication medium.

Understanding I2C addressing helps grasp how IP addresses uniquely identify computers on a network, showing a shared principle of unique identification in communication.

Binary Number Systems

I2C addresses are binary numbers representing device IDs.

Knowing binary helps understand how addresses are structured and manipulated, such as shifting bits and masking.

Semaphore Locks in Operating Systems

Both manage access to shared resources to avoid conflicts.

I2C addressing ensures only one device responds at a time, similar to how semaphores prevent multiple processes from accessing a resource simultaneously.

Common Pitfalls

#1 Using 7-bit address without shifting when the API expects shifted address.

Wrong approach:

uint8_t addr = 0x3C; // No shift
I2C_Write(addr, data);

Correct approach:

uint8_t addr = 0x3C << 1; // Shift left to make room for R/W bit
I2C_Write(addr, data);

Root cause:

Misunderstanding how the API expects the address format leads to wrong device addressing.

#2 Trying to use 10-bit addressing on hardware that only supports 7-bit mode.

Wrong approach:

// Attempt 10-bit address without hardware support
I2C_Start();
I2C_SendByte(0xF0); // 10-bit prefix
I2C_SendByte(0x12); // rest of address
// Communication fails

Correct approach:

// Use only 7-bit addressing or switch hardware
I2C_Start();
I2C_SendByte(0x3C << 1); // 7-bit address shifted
// Communication succeeds

Root cause:

Hardware limitations prevent proper handling of extended addressing.

#3 Confusing the read/write bit as part of the device address in calculations.

Wrong approach:

uint8_t addr = 0x3D; // Incorrectly includes R/W bit
I2C_Write(addr, data);

Correct approach:

uint8_t addr = 0x3C << 1; // Address only, R/W bit added by hardware or API
I2C_Write(addr, data);

Root cause:

Misunderstanding the role of the read/write bit causes wrong address bytes sent.

Key Takeaways

I2C addressing uniquely identifies devices on a shared bus using 7-bit or 10-bit addresses.

7-bit addressing is most common and uses one byte with a read/write bit appended.

10-bit addressing extends the address space using a special prefix and two bytes, but requires hardware support.

Correctly formatting addresses in code, including shifting and mode selection, is essential for reliable communication.

Understanding hardware limitations and reserved addresses prevents common communication errors in embedded systems.