I2C bus architecture (SDA, SCL) in Embedded C - Mini Project: Build & Apply

I2C Bus Architecture: Understanding SDA and SCL Lines

📖 Scenario: You are working on a small embedded system that communicates with a sensor using the I2C bus. The I2C bus uses two lines: SDA (data line) and SCL (clock line). Your task is to simulate the basic setup and operation of these lines in code.

🎯 Goal: Build a simple embedded C program that sets up the SDA and SCL lines as variables, configures a clock speed, simulates sending data bits over the SDA line synchronized with the SCL clock, and finally prints the transmitted data bits.

📋 What You'll Learn

Create variables representing the SDA and SCL lines

Set a clock speed variable for the SCL line

Simulate sending a byte of data bit by bit over SDA synchronized with SCL

Print the transmitted bits to show the data sent

💡 Why This Matters

🌍 Real World

I2C is a common communication protocol used in embedded systems to connect sensors, displays, and other devices using just two wires.

💼 Career

Understanding how to manipulate and simulate I2C signals in code is useful for embedded software engineers working on hardware communication and device drivers.

1

Setup SDA and SCL lines

Create two integer variables called SDA and SCL and initialize both to 1 to represent idle high lines.

Embedded C

int SDA = 1;
int SCL = 1;
// Your code here

Hint

In I2C, both SDA and SCL lines are high when idle. Use int variables to represent these lines.

2

Configure SCL clock speed

Create an integer variable called clock_speed_khz and set it to 100 to represent 100 kHz clock speed for the SCL line.

Embedded C

int SDA = 1;
int SCL = 1;
int clock_speed_khz = 100;
// Your code here

Hint

The SCL clock speed is often set in kilohertz. Use an integer variable to store this value.

3

Simulate sending data bits over SDA synchronized with SCL

Create a character array data with the value {0xA5}. Then write a for loop using int i from 7 down to 0 to extract each bit from data[0]. Inside the loop, set SDA to the current bit value (0 or 1) using bitwise operations.

Embedded C

int SDA = 1;
int SCL = 1;
int clock_speed_khz = 100;
char data[1] = {0xA5};
for (int i = 7; i >= 0; i--) {
    // Your code here
}

Hint

Use bit shifting and bitwise AND to get each bit from the byte. Loop from the most significant bit (7) down to 0.

4

Print transmitted bits

Inside the for loop, add a printf statement to print the current SDA bit value without a newline. After the loop, print a newline character.

Embedded C

int SDA = 1;
int SCL = 1;
int clock_speed_khz = 100;
char data[1] = {0xA5};
for (int i = 7; i >= 0; i--) {
    SDA = (data[0] >> i) & 1;
    // Your code here
}
// Your code here

Hint

Use printf("%d", SDA); inside the loop to print bits continuously, then print a newline after the loop.

Practice

1. Which two lines are used in the I2C bus architecture for communication?

easy

A. CLK for data and DAT for clock

B. TX for data and RX for clock

C. SDA for data and SCL for clock

D. MOSI for data and MISO for clock

Solution

1. Step 1: Recall I2C bus lines

   I2C uses two specific lines: SDA and SCL.

2. Step 2: Identify roles of lines

   SDA carries data, and SCL carries the clock signal.

3. Final Answer:

   SDA for data and SCL for clock -> Option C

4. Quick Check:

   I2C lines = SDA + SCL [OK]

Hint: Remember: SDA = data, SCL = clock [OK]

Common Mistakes:

• Confusing I2C lines with SPI lines
• Mixing data and clock line names
• Assuming more than two lines are used

2. Which of the following correctly describes the state of the SDA and SCL lines when no device is pulling them low on an I2C bus?

easy

A. SDA is high, SCL is low

B. Both lines are low

C. SDA is low, SCL is high

D. Both lines are high

Solution

1. Step 1: Understand line behavior on I2C bus

   Lines are open-drain and pulled high by resistors when released.

2. Step 2: Determine line state when idle

   When no device pulls lines low, both SDA and SCL remain high.

3. Final Answer:

   Both lines are high -> Option D

4. Quick Check:

   Idle I2C lines = high [OK]

Hint: Lines float high unless pulled low [OK]

Common Mistakes:

• Assuming lines default to low
• Confusing line states during communication
• Ignoring pull-up resistor effect

3. Consider this snippet controlling I2C lines in embedded C:

if (SDA == 1 && SCL == 1) {
    // Start condition detected
} else if (SDA == 0 && SCL == 1) {
    // Stop condition detected
}

What is the output behavior of this code snippet?

medium

A. Detects start when SDA goes low while SCL is high

B. Detects stop when SDA goes high while SCL is low

C. Detects start when SDA and SCL are both low

D. Detects stop when SDA and SCL are both high

Solution

1. Step 1: Recall I2C start and stop conditions

   Start condition: SDA falls low while SCL is high. Stop condition: SDA rises high while SCL is high.

2. Step 2: Analyze code conditions

   The code checks if SDA and SCL are both high for start, which is incorrect; start is when SDA falls low while SCL is high.

3. Final Answer:

   Detects start when SDA goes low while SCL is high -> Option A

4. Quick Check:

   Start = SDA low + SCL high [OK]

Hint: Start = SDA falls low while SCL high [OK]

Common Mistakes:

• Mixing start and stop conditions
• Checking both lines high for start
• Ignoring SDA line change direction

4. This embedded C code snippet is intended to detect an I2C stop condition:

if (SDA == 1 && SCL == 0) {
    // Stop condition detected
}

What is the error in this code?

medium

A. Stop condition requires SCL to be high, not low

B. SDA should be low, not high for stop condition

C. Both SDA and SCL should be low for stop condition

D. No error; code correctly detects stop condition

Solution

1. Step 1: Recall stop condition timing

   Stop condition occurs when SDA rises from low to high while SCL is high.

2. Step 2: Check code condition

   The code checks SDA high and SCL low, which is incorrect; SCL must be high for stop.

3. Final Answer:

   Stop condition requires SCL to be high, not low -> Option A

4. Quick Check:

   Stop = SDA high + SCL high [OK]

Hint: Stop needs SCL high, not low [OK]

Common Mistakes:

• Confusing clock line state for stop
• Assuming SDA low means stop
• Ignoring line state transitions

5. You want to implement a function in embedded C that waits for the I2C start condition before proceeding. Which logic correctly detects the start condition on SDA and SCL lines?

hard

A. Wait until SDA changes from low to high while SCL is low

B. Wait until SDA changes from high to low while SCL is high

C. Wait until both SDA and SCL are low simultaneously

D. Wait until SCL changes from low to high while SDA is low

Solution

1. Step 1: Understand start condition in I2C

   Start condition is when SDA line falls from high to low while SCL line is high.

2. Step 2: Match logic to condition

   Wait until SDA changes from high to low while SCL is high correctly waits for SDA falling edge with SCL high, matching start condition.

3. Final Answer:

   Wait until SDA changes from high to low while SCL is high -> Option B

4. Quick Check:

   Start = SDA high-to-low + SCL high [OK]

Hint: Start = SDA falls low while SCL high [OK]

Common Mistakes:

• Waiting for SDA rising edge instead of falling
• Checking SCL low instead of high
• Confusing start with stop condition