I2C acknowledge and NACK behavior in Embedded C - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to send an ACK after receiving a byte on I2C.

Embedded C

if (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)) {
    uint8_t data = I2C_ReceiveData(I2C1);
    I2C_[1](I2C1, ENABLE);  // Send ACK
}

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

ANACKConfig

BAcknowledgeConfig

CStopConfig

DStartConfig

Attempts:

3 left

💡 Hint

Common Mistakes

Using NACKConfig instead of AcknowledgeConfig

Confusing StopConfig with ACK control

The function AcknowledgeConfig enables sending an ACK after receiving a byte.

2fill in blank

medium

Complete the code to send a NACK after the last byte is received on I2C.

Embedded C

if (last_byte_received) {
    I2C_[1](I2C1, ENABLE);  // Send NACK
}

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

AAcknowledgeConfig

BStopConfig

CNACKConfig

DStartConfig

Attempts:

3 left

💡 Hint

Common Mistakes

Using AcknowledgeConfig instead of NACKConfig

Forgetting to send NACK after last byte

To signal the end of data reception, NACKConfig is enabled to send a NACK.

3fill in blank

hard

Fix the error in the code to properly generate a NACK after receiving the last byte.

Embedded C

if (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)) {
    if (last_byte) {
        I2C_AcknowledgeConfig(I2C1, [1]);  // Should send NACK
    }
    uint8_t data = I2C_ReceiveData(I2C1);
}

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

ADISABLE

BENABLE

CTRUE

DFALSE

Attempts:

3 left

💡 Hint

Common Mistakes

Passing ENABLE instead of DISABLE

Not disabling acknowledge before last byte

To send a NACK, the acknowledge must be disabled by passing DISABLE.

4fill in blank

hard

Fill both blanks to correctly check for ACK and NACK events in I2C communication.

Embedded C

if (I2C_CheckEvent(I2C1, [1])) {
    // ACK received
}
else if (I2C_CheckEvent(I2C1, [2])) {
    // NACK received
}

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

AI2C_EVENT_MASTER_BYTE_TRANSMITTED

BI2C_EVENT_MASTER_BYTE_RECEIVED

CI2C_EVENT_MASTER_NACK

DI2C_EVENT_MASTER_MODE_SELECT

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing transmit and receive events

Using wrong event constants

I2C_EVENT_MASTER_BYTE_RECEIVED indicates an ACK after byte reception, and I2C_EVENT_MASTER_NACK indicates a NACK event.

5fill in blank

hard

Fill all three blanks to implement sending a NACK and STOP condition after the last byte is received.

Embedded C

if (last_byte) {
    I2C_AcknowledgeConfig(I2C1, [1]);  // Send NACK
    I2C_GenerateSTOP(I2C1, [2]);          // Generate STOP
    while (!I2C_GetFlagStatus(I2C1, [3])) {}
}

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

ADISABLE

BENABLE

CI2C_FLAG_STOPF

DI2C_FLAG_TXE

Attempts:

3 left

💡 Hint

Common Mistakes

Enabling acknowledge instead of disabling

Waiting for wrong flag

Not generating STOP condition

To send a NACK, acknowledge is disabled (DISABLE). The STOP condition is generated by enabling it (ENABLE). The code waits for the STOP flag (I2C_FLAG_STOPF) to confirm the STOP condition.

Practice

1. What does an ACK (Acknowledge) signal mean in I2C communication?

easy

A. The sender is requesting to resend the data

B. The receiver wants to stop communication immediately

C. The communication line is idle

D. The receiver successfully received data and is ready for more

Solution

1. Step 1: Understand ACK meaning in I2C

   ACK means the receiver signals it has received the data correctly and is ready to continue.

2. Step 2: Compare options with ACK meaning

   Only The receiver successfully received data and is ready for more matches this meaning; others describe stop or errors.

3. Final Answer:

   The receiver successfully received data and is ready for more -> Option D

4. Quick Check:

   ACK = Ready for more data [OK]

Hint: ACK means receiver says 'send more' [OK]

Common Mistakes:

• Confusing ACK with NACK meaning
• Thinking ACK means stop communication
• Assuming ACK means error occurred

2. Which of the following code snippets correctly sends a NACK after reading the last byte in I2C using embedded C?

easy

A. i2c_read_byte(I2C1, ACK);

B. i2c_read_byte(I2C1, NACK);

C. i2c_write_byte(I2C1, NACK);

D. i2c_send_ack(I2C1);

Solution

1. Step 1: Identify correct function to read with NACK

   To signal no more data is needed, the read function must be called with NACK.

2. Step 2: Check options for correct usage

   i2c_read_byte(I2C1, NACK); uses i2c_read_byte with NACK, which is correct. Others either send ACK or write instead of read.

3. Final Answer:

   i2c_read_byte(I2C1, NACK); -> Option B

4. Quick Check:

   Read last byte with NACK to stop [OK]

Hint: Use read with NACK to stop reading last byte [OK]

Common Mistakes:

• Using ACK instead of NACK after last byte
• Calling write instead of read for NACK
• Confusing function names for ACK/NACK

3. Consider this code snippet reading 3 bytes from an I2C device:

for (int i = 0; i < 3; i++) {
  data[i] = (i < 2) ? i2c_read_byte(I2C1, ACK) : i2c_read_byte(I2C1, NACK);
}

What is the purpose of sending NACK on the last byte?

medium

A. To request the device to resend the last byte

B. To acknowledge the last byte and continue reading

C. To indicate the master will stop reading after this byte

D. To reset the I2C bus immediately

Solution

1. Step 1: Analyze the loop and ACK/NACK usage

   The loop reads 3 bytes; for first two bytes it sends ACK, for last byte it sends NACK.

2. Step 2: Understand NACK meaning on last byte

   NACK signals the master will stop reading after this byte, telling the slave no more data is needed.

3. Final Answer:

   To indicate the master will stop reading after this byte -> Option C

4. Quick Check:

   NACK on last byte = stop reading [OK]

Hint: NACK on last byte means stop reading [OK]

Common Mistakes:

• Thinking NACK requests resend
• Assuming NACK resets bus
• Confusing ACK and NACK roles

4. You wrote this code to read bytes from I2C but the slave device never stops sending data:

for (int i = 0; i < 4; i++) {
  data[i] = i2c_read_byte(I2C1, ACK);
}

What is the likely problem?

medium

A. You never sent NACK after the last byte to stop reading

B. You should use i2c_write_byte instead of i2c_read_byte

C. The loop should run 5 times instead of 4

D. You need to send a STOP condition before reading

Solution

1. Step 1: Check ACK/NACK usage in the loop

   The code sends ACK for every byte read, never sending NACK to signal stop.

2. Step 2: Understand effect of missing NACK

   Without NACK after last byte, slave keeps sending data, causing endless transmission.

3. Final Answer:

   You never sent NACK after the last byte to stop reading -> Option A

4. Quick Check:

   Missing NACK means no stop signal [OK]

Hint: Send NACK after last byte to stop slave [OK]

Common Mistakes:

• Using ACK for all bytes including last
• Confusing read and write functions
• Ignoring need for STOP condition after read

5. You want to write a function that reads a variable number of bytes from an I2C device and properly sends ACK for all bytes except the last one, which should send NACK. Which code snippet correctly implements this behavior?

hard

A. for (int i = 0; i < length - 1; i++) {
data[i] = i2c_read_byte(I2C1, ACK);
}
data[length - 1] = i2c_read_byte(I2C1, NACK);

B. for (int i = 0; i < length; i++) {
data[i] = i2c_read_byte(I2C1, ACK);
}

C. for (int i = 0; i < length; i++) {
data[i] = i2c_read_byte(I2C1, NACK);
}

D. data[0] = i2c_read_byte(I2C1, NACK);
for (int i = 1; i < length; i++) {
data[i] = i2c_read_byte(I2C1, ACK);
}

Solution

1. Step 1: Understand ACK/NACK pattern for multiple bytes

   All bytes except last must be read with ACK; last byte with NACK to stop.

2. Step 2: Analyze each option

   for (int i = 0; i < length - 1; i++) { data[i] = i2c_read_byte(I2C1, ACK); } data[length - 1] = i2c_read_byte(I2C1, NACK); reads all but last byte with ACK, then last byte with NACK, correctly signaling stop. Others send wrong signals or in wrong order.

3. Final Answer:

   for (int i = 0; i < length - 1; i++) { data[i] = i2c_read_byte(I2C1, ACK); } data[length - 1] = i2c_read_byte(I2C1, NACK); -> Option A

4. Quick Check:

   ACK all but last, NACK last byte [OK]

Hint: Send NACK only on last byte read [OK]

Common Mistakes:

• Sending NACK on all bytes
• Sending ACK on last byte
• Reading last byte first with NACK