Why I2C is used in Embedded C - Why It Works This Way

Overview - Why I2C is used

What is it?

I2C is a communication method used in electronics to connect multiple devices using just two wires. It allows microcontrollers and sensors to talk to each other easily and efficiently. This method uses a simple protocol to send and receive data between devices on the same bus. It is popular because it reduces wiring complexity and supports many devices on one connection.

Why it matters

Without I2C, connecting multiple sensors or components to a microcontroller would require many wires, making devices bulky and complicated. I2C solves this by using only two wires for communication, saving space and cost. This makes it easier to build compact and reliable electronic systems like smart watches, home appliances, and robots.

Where it fits

Before learning I2C, you should understand basic digital electronics and how microcontrollers work. After mastering I2C, you can learn other communication protocols like SPI and UART, which offer different speed and complexity trade-offs.

Mental Model

Core Idea

I2C is a simple two-wire communication system that lets many devices share data on the same connection without confusion.

Think of it like...

Imagine a classroom where a teacher (microcontroller) talks to many students (devices) using just one microphone and one speaker wire. Each student has a unique name (address) so the teacher knows who to talk to and who should listen.

┌─────────────┐
│  Microcontroller  │
└──────┬──────┘
       │ SDA (Data Line)
       │
       │
       │
       │ SCL (Clock Line)
       │
┌──────┴──────┐
│ Multiple Devices │
│ (Sensors, etc.)  │
└─────────────────┘

Build-Up - 7 Steps

1

Foundation

Basic Two-Wire Communication

Concept: I2C uses two wires: one for data and one for clock signals.

I2C stands for Inter-Integrated Circuit. It uses two wires called SDA (data) and SCL (clock). The clock wire controls timing, and the data wire carries information. Both wires are connected to all devices on the bus.

Result

Devices can send and receive data using just two wires.

Understanding the two-wire setup is key to seeing how I2C reduces wiring complexity.

2

Foundation

Device Addressing on the Bus

Concept: Each device on the I2C bus has a unique address to identify it.

To communicate, the microcontroller sends the address of the device it wants to talk to. Only the device with that address responds, while others stay silent. This allows many devices to share the same two wires without talking over each other.

Result

Multiple devices can share the same bus without confusion.

Knowing device addressing explains how I2C manages many devices on just two wires.

3

Intermediate

Master and Slave Roles

Concept: I2C devices have roles: one master controls the bus, others are slaves.

The master device starts communication by sending clock signals and addresses. Slaves respond when addressed. Usually, the microcontroller is the master, and sensors or memory chips are slaves. This structure keeps communication organized.

Result

Clear control flow prevents data collisions on the bus.

Understanding roles helps explain how I2C avoids communication conflicts.

4

Intermediate

Data Transfer and Acknowledgment

Concept: Data is sent in bytes, and receivers confirm receipt with acknowledgments.

After the master sends a byte, the slave sends an acknowledgment bit to confirm it received the data. This handshake ensures reliable communication. Data flows in sequences controlled by the clock line.

Result

Data is transferred reliably with error checking.

Knowing about acknowledgments reveals how I2C maintains data integrity.

5

Intermediate

Multi-Master and Arbitration

🤔Before reading on: do you think I2C allows more than one master device at the same time? Commit to your answer.

Concept: I2C can support multiple masters, but they must avoid conflicts using arbitration.

Sometimes more than one master tries to control the bus. I2C uses arbitration to decide who gets control without data loss. Masters listen while sending data and stop if they detect another master sending a higher priority message.

Result

Multiple masters can share the bus safely without corrupting data.

Understanding arbitration explains how I2C handles complex systems with several controllers.

6

Advanced

Why I2C Saves Space and Power

🤔Before reading on: do you think fewer wires always mean slower communication? Commit to your answer.

Concept: I2C reduces wiring and power consumption, making it ideal for small, battery-powered devices.

Because I2C uses only two wires and simple signaling, it needs less physical space and less power than other protocols. This is why it is common in portable devices like phones and wearables. However, it trades off speed compared to some other methods.

Result

Devices can be smaller and last longer on batteries.

Knowing the trade-offs helps choose I2C for the right applications.

7

Expert

Electrical Characteristics and Pull-Up Resistors

🤔Before reading on: do you think I2C lines are actively driven high and low by devices? Commit to your answer.

Concept: I2C lines use open-drain outputs and pull-up resistors to allow multiple devices to share the bus safely.

I2C devices can only pull the lines low; they cannot drive them high. Instead, pull-up resistors connected to the power line keep the lines high when no device pulls them low. This design prevents damage and allows many devices to connect without electrical conflicts.

Result

The bus remains stable and safe even with many devices connected.

Understanding open-drain and pull-ups clarifies why I2C is robust and scalable.

Under the Hood

I2C works by having devices connected to two shared lines: SDA for data and SCL for clock. Devices use open-drain outputs, meaning they can only pull the line low or release it. Pull-up resistors keep the lines high when released. The master device generates clock pulses on SCL to synchronize data bits sent on SDA. Each data byte is followed by an acknowledgment bit from the receiver. Devices have unique 7-bit or 10-bit addresses to identify them. If multiple masters exist, arbitration ensures only one controls the bus at a time by monitoring the lines while transmitting.

Why designed this way?

I2C was designed in the 1980s by Philips to simplify wiring inside TVs and other electronics. The goal was to reduce the number of wires needed to connect chips, lowering cost and complexity. Open-drain lines with pull-ups were chosen to allow multiple devices to share the bus safely without electrical damage. The simple master-slave protocol and addressing scheme made it easy to add many devices. Alternatives like SPI require more wires, and UART is point-to-point, so I2C fills a unique niche.

┌─────────────┐       ┌─────────────┐
│   Master    │───────│   Slave 1   │
│ (Controller)│       └─────────────┘
└─────┬───────┘
      │ SDA & SCL lines shared
      │
┌─────┴───────┐       ┌─────────────┐
│   Slave 2   │       │   Slave 3   │
└─────────────┘       └─────────────┘

Lines are pulled high by resistors when no device pulls low.

Myth Busters - 4 Common Misconceptions

Quick: Does I2C require separate wires for each device? Commit to yes or no before reading on.

Common Belief: I2C needs a separate wire for each device to communicate.

Reality: I2C uses only two shared wires for all devices, regardless of how many are connected.

Why it matters: Believing this leads to unnecessarily complex wiring and misses the main advantage of I2C.

Quick: Can I2C devices drive the data line high directly? Commit to yes or no before reading on.

Common Belief: Devices on I2C can actively drive the data line both high and low.

Reality: I2C devices only pull the line low; the line is pulled high by resistors when released.

Why it matters: Misunderstanding this can cause hardware damage or bus conflicts when designing circuits.

Quick: Is I2C always faster than SPI? Commit to yes or no before reading on.

Common Belief: I2C is faster than other communication protocols like SPI.

Reality: I2C is generally slower than SPI but uses fewer wires and supports multiple devices more easily.

Why it matters: Choosing I2C for speed-critical applications can cause performance issues.

Quick: Can multiple masters send data at the same time without conflict? Commit to yes or no before reading on.

Common Belief: Multiple masters can send data simultaneously on I2C without problems.

Reality: I2C uses arbitration to prevent conflicts; only one master controls the bus at a time.

Why it matters: Ignoring arbitration can cause data corruption and unpredictable device behavior.

Expert Zone

1

The choice of pull-up resistor value affects bus speed and power consumption, requiring careful tuning for optimal performance.

2

I2C supports 7-bit and 10-bit addressing, but 10-bit is less common and may not be supported by all devices.

3

Clock stretching allows slower devices to hold the clock line low to delay communication, but not all masters handle this correctly.

When NOT to use

I2C is not ideal for very high-speed communication or long-distance wiring. In such cases, SPI or UART may be better choices. Also, if only two devices need to communicate, simpler protocols might suffice.

Production Patterns

In real products, I2C is used to connect sensors, EEPROMs, and display controllers on a single bus. Designers often use level shifters to connect devices with different voltage levels and implement software retries to handle bus errors gracefully.

Connections

SPI Communication Protocol

Alternative communication method with different wiring and speed trade-offs.

Understanding I2C helps compare its simplicity and multi-device support to SPI's speed and full-duplex communication.

Computer Networking

Both use addressing and arbitration to manage communication between multiple devices.

Knowing how I2C handles device addressing and bus arbitration parallels how networks avoid data collisions.

Traffic Control Systems

I2C arbitration is like traffic lights managing multiple cars wanting to cross an intersection safely.

This connection shows how managing shared resources requires rules to avoid conflicts, whether in electronics or traffic.

Common Pitfalls

#1 Connecting I2C devices without pull-up resistors.

Wrong approach:

Microcontroller SDA and SCL pins connected directly to devices without any resistors.

Correct approach:

Add pull-up resistors (typically 4.7kΩ) from SDA and SCL lines to the positive voltage supply.

Root cause:

Misunderstanding that I2C lines need pull-ups to stay high when no device pulls them low.

#2 Using the same address for two devices on the bus.

Wrong approach:

Two sensors configured with identical I2C addresses connected to the same bus.

Correct approach:

Ensure each device has a unique address or use devices with configurable addresses.

Root cause:

Not checking device datasheets for address conflicts leads to communication errors.

#3 Ignoring clock stretching support in master device.

Wrong approach:

Master device code does not wait for slaves to release the clock line during clock stretching.

Correct approach:

Implement clock stretching handling by checking the clock line state before sending next bit.

Root cause:

Assuming all devices communicate at the same speed without delays.

Key Takeaways

I2C is a two-wire communication protocol that allows many devices to share a single bus using unique addresses.

It uses open-drain lines with pull-up resistors to safely connect multiple devices without electrical conflicts.

Master and slave roles organize communication, with arbitration handling multiple masters if present.

I2C reduces wiring complexity and power consumption, making it ideal for compact and battery-powered devices.

Understanding I2C's design and limitations helps choose the right communication method for embedded systems.

Practice

1. Why is I2C commonly used in embedded systems?

easy

A. It uses wireless signals for communication.

B. It requires a separate wire for each device.

C. It only supports one device at a time.

D. It allows multiple devices to communicate using only two wires.

Solution

1. Step 1: Understand I2C wiring

   I2C uses two wires: SDA (data) and SCL (clock) to connect devices.

2. Step 2: Recognize multi-device communication

   Multiple devices share these two wires, communicating by unique addresses.

3. Final Answer:

   It allows multiple devices to communicate using only two wires. -> Option D

4. Quick Check:

   I2C uses 2 wires for many devices [OK]

Hint: I2C uses 2 wires for many devices, not one per device [OK]

Common Mistakes:

• Thinking each device needs its own wire
• Confusing I2C with wireless communication
• Believing only one device can connect

2. Which of the following is the correct way to describe I2C communication lines?

easy

A. Separate data and clock lines for each device

B. Only one wire for both data and clock

C. Single data line and single clock line shared by all devices

D. Wireless data and wired clock lines

Solution

1. Step 1: Identify I2C lines

   I2C uses two lines: SDA for data and SCL for clock.

2. Step 2: Understand line sharing

   Both lines are shared by all devices on the bus, not separate per device.

3. Final Answer:

   Single data line and single clock line shared by all devices -> Option C

4. Quick Check:

   I2C shares SDA and SCL lines [OK]

Hint: I2C shares one data and one clock line for all devices [OK]

Common Mistakes:

• Assuming separate lines per device
• Thinking data and clock share one wire
• Confusing wireless with wired lines

3. You want to connect 5 sensors to a microcontroller using I2C. What is the main advantage of using I2C here?

easy

A. Each sensor needs its own data and clock wires

B. You can use only two wires total for all sensors

C. Sensors communicate wirelessly with microcontroller

D. I2C requires no addressing for devices

Solution

1. Step 1: Understand wiring for multiple devices

   I2C allows multiple devices to share the same two wires: SDA and SCL.

2. Step 2: Recognize wiring advantage

   This saves pins and wiring complexity compared to separate wires per sensor.

3. Final Answer:

   You can use only two wires total for all sensors -> Option B

4. Quick Check:

   Two wires for many devices saves pins [OK]

Hint: I2C uses 2 wires total regardless of device count [OK]

Common Mistakes:

• Thinking each sensor needs separate wires
• Assuming I2C is wireless
• Believing devices don't need addresses

4. Consider this I2C communication snippet in embedded C:

i2c_start();
i2c_write(0x50); // device address
uint8_t data = i2c_read();
i2c_stop();
printf("%d", data);

What does this code do?

medium

A. Starts I2C, writes device address, reads one byte, stops, prints data

B. Starts I2C, reads device address, writes one byte, stops, prints data

C. Starts I2C, writes data, reads address, stops, prints data

D. Starts I2C, stops immediately, prints zero

Solution

1. Step 1: Analyze I2C function calls

   i2c_start() begins communication, i2c_write(0x50) sends device address.

2. Step 2: Understand data flow

   i2c_read() reads one byte from the device, i2c_stop() ends communication, printf prints the data.

3. Final Answer:

   Starts I2C, writes device address, reads one byte, stops, prints data -> Option A

4. Quick Check:

   Write address, read data, stop, print [OK]

Hint: Write address before reading data in I2C [OK]

Common Mistakes:

• Mixing read and write order
• Assuming stop happens before read
• Confusing address with data

5. This embedded C code tries to communicate over I2C but fails:

i2c_write(0x50);
i2c_start();
i2c_read();
i2c_stop();

What is the main error?

medium

A. Calling i2c_write before i2c_start

B. Missing device address in i2c_write

C. Not calling i2c_stop before i2c_start

D. Reading data before writing device address

Solution

1. Step 1: Check function call order

   i2c_start() must be called before i2c_write() to begin communication.

2. Step 2: Identify error

   Here, i2c_write() is called before i2c_start(), which is incorrect and causes failure.

3. Final Answer:

   Calling i2c_write before i2c_start -> Option A

4. Quick Check:

   Start communication before writing [OK]

Hint: Always call i2c_start() before i2c_write() [OK]

Common Mistakes:

• Writing before starting communication
• Ignoring function call order
• Assuming stop must come before start