SPI data transfer sequence in Embedded C - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start the SPI data transfer by enabling the SPI peripheral.

Embedded C

SPI->[1] |= SPI_CR1_SPE;

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

ACR1

BDR

CSR

DCR2

Attempts:

3 left

💡 Hint

Common Mistakes

Using data register (DR) instead of control register.

Trying to enable SPI in status register (SR).

The SPI control register 1 (CR1) contains the SPE bit which enables the SPI peripheral.

2fill in blank

medium

Complete the code to wait until the SPI transmit buffer is empty before sending data.

Embedded C

while (!(SPI->SR & [1]));

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

ASPI_SR_TXE

BSPI_SR_BSY

CSPI_SR_OVR

DSPI_SR_RXNE

Attempts:

3 left

💡 Hint

Common Mistakes

Waiting for RXNE (receive buffer not empty) instead of TXE.

Checking BSY flag incorrectly.

The TXE (Transmit buffer empty) flag in the status register (SR) indicates when the transmit buffer is ready for new data.

3fill in blank

hard

Fix the error in the code that writes data to the SPI data register.

Embedded C

SPI->[1] = data;

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

ASR

BCR2

CCR1

DDR

Attempts:

3 left

💡 Hint

Common Mistakes

Writing data to control or status registers instead of data register.

The data register (DR) is used to write data to be transmitted via SPI.

4fill in blank

hard

Fill both blanks to check if SPI is busy and wait until it is free before disabling it.

Embedded C

while (SPI->SR & [1]) {} 
SPI->[2] &= ~SPI_CR1_SPE;

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

ASPI_SR_BSY

BSPI_SR_TXE

CCR1

DDR

Attempts:

3 left

💡 Hint

Common Mistakes

Checking wrong flags or disabling SPI in wrong register.

The BSY flag in the status register (SR) shows if SPI is busy. The SPI is disabled by clearing SPE bit in CR1.

5fill in blank

hard

Fill all three blanks to create a function that sends a byte over SPI and waits for completion.

Embedded C

void SPI_SendByte(uint8_t data) {
    while (!(SPI->SR & [1]));
    SPI->[2] = data;
    while (SPI->SR & [3]) {}
}

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

ASPI_SR_TXE

BDR

CSPI_SR_BSY

DCR1

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong flags or registers in the function.

This function waits for the transmit buffer to be empty (TXE), writes data to the data register (DR), then waits until SPI is not busy (BSY) before returning.

Practice

1. In SPI communication, what happens during a data transfer sequence?

easy

A. Data is only sent, no data is received.

B. Data is sent and received simultaneously, one byte at a time.

C. Data is received first, then sent after completion.

D. Data is sent in large blocks without waiting for response.

Solution

1. Step 1: Understand SPI full-duplex nature

   SPI sends and receives data simultaneously, byte by byte.

2. Step 2: Confirm data transfer behavior

   Each byte sent triggers a byte received at the same time.

3. Final Answer:

   Data is sent and received simultaneously, one byte at a time. -> Option B

4. Quick Check:

   SPI full-duplex = simultaneous send/receive [OK]

Hint: Remember SPI sends and receives one byte at a time simultaneously [OK]

Common Mistakes:

• Thinking SPI only sends data without receiving
• Assuming data is received after all sending completes
• Believing SPI transfers data in large blocks

2. Which of the following code snippets correctly waits for SPI transfer completion before reading received data?

easy

A. while(!(SPI_SR & SPI_SR_RXNE)); uint8_t data = SPI_DR;

B. uint8_t data = SPI_DR; while(!(SPI_SR & SPI_SR_RXNE));

C. while(SPI_SR & SPI_SR_BSY); uint8_t data = SPI_DR;

D. while(!(SPI_SR & SPI_SR_TXE)); uint8_t data = SPI_DR;

Solution

1. Step 1: Identify the correct flag for received data ready

   SPI_SR_RXNE indicates data received and ready to read.

2. Step 2: Confirm waiting loop and reading order

   Wait until RXNE is set, then read SPI_DR to get received byte.

3. Final Answer:

   while(!(SPI_SR & SPI_SR_RXNE)); uint8_t data = SPI_DR; -> Option A

4. Quick Check:

   Wait RXNE flag before reading data [OK]

Hint: Wait for RXNE flag before reading SPI data register [OK]

Common Mistakes:

• Waiting for TXE instead of RXNE
• Reading data before checking RXNE flag
• Waiting for BSY flag incorrectly

3. Given the following code snippet, what will be the content of the array received[3] after execution?

uint8_t data_to_send[3] = {0xA1, 0xB2, 0xC3};
uint8_t received[3];
for(int i = 0; i < 3; i++) {
  SPI_DR = data_to_send[i];
  while(!(SPI_SR & SPI_SR_RXNE));
  received[i] = SPI_DR;
}

medium

A. [0xA1, 0xB2, 0xC3]

B. [unknown garbage values]

C. [data received from SPI slave during transfer]

D. [0x00, 0x00, 0x00]

Solution

1. Step 1: Understand SPI transfer behavior

   Each byte sent causes a byte to be received simultaneously from the slave device.

2. Step 2: Analyze received array assignment

   received[i] stores the byte read from SPI_DR after waiting for RXNE flag.

3. Final Answer:

   Data received from SPI slave during transfer -> Option C

4. Quick Check:

   Received array = slave response bytes [OK]

Hint: Received data is from slave, not the sent bytes [OK]

Common Mistakes:

• Assuming received data equals sent data
• Ignoring that SPI_DR reads slave response
• Expecting zeros or uninitialized values

4. Identify the error in this SPI data transfer loop:

for(int i = 0; i < 4; i++) {
  SPI_DR = data[i];
  received[i] = SPI_DR;
  while(!(SPI_SR & SPI_SR_RXNE));
}

medium

A. Loop counter exceeds array size.

B. Not sending data before reading.

C. Missing SPI enable command.

D. Reading SPI_DR before waiting for RXNE flag.

Solution

1. Step 1: Check order of reading SPI_DR and waiting for RXNE

   The code reads SPI_DR before waiting for RXNE flag, which is incorrect.

2. Step 2: Correct sequence for SPI read

   Must wait for RXNE flag before reading SPI_DR to get valid received data.

3. Final Answer:

   Reading SPI_DR before waiting for RXNE flag. -> Option D

4. Quick Check:

   Wait RXNE before reading SPI_DR [OK]

Hint: Always wait RXNE flag before reading SPI_DR [OK]

Common Mistakes:

• Reading SPI_DR too early
• Ignoring RXNE flag status
• Assuming data is ready immediately after writing

5. You want to send an array of 5 bytes over SPI and store the received bytes simultaneously. Which code snippet correctly implements this transfer sequence?

hard

A. for(int i=0; i<5; i++) { SPI_DR = tx[i]; while(!(SPI_SR & SPI_SR_RXNE)); rx[i] = SPI_DR; }

B. for(int i=0; i<5; i++) { while(!(SPI_SR & SPI_SR_TXE)); SPI_DR = tx[i]; rx[i] = SPI_DR; }

C. for(int i=0; i<5; i++) { SPI_DR = tx[i]; rx[i] = SPI_DR; while(!(SPI_SR & SPI_SR_RXNE)); }

D. for(int i=0; i<5; i++) { while(SPI_SR & SPI_SR_BSY); SPI_DR = tx[i]; rx[i] = SPI_DR; }

Solution

1. Step 1: Confirm correct order of operations

   Send byte by writing SPI_DR, wait for RXNE flag, then read received byte.

2. Step 2: Validate correct snippet

   The correct snippet writes SPI_DR, waits for RXNE, then reads SPI_DR into rx array correctly.

3. Step 3: Check distractors for errors

   Others read SPI_DR before RXNE is set, read before waiting, or wait for incorrect flags like BSY.

4. Final Answer:

   for(int i=0; i<5; i++) { SPI_DR = tx[i]; while(!(SPI_SR & SPI_SR_RXNE)); rx[i] = SPI_DR; } -> Option A

5. Quick Check:

   Send, wait RXNE, then read = correct SPI transfer [OK]

Hint: Send byte, wait RXNE flag, then read received byte [OK]

Common Mistakes:

• Reading SPI_DR before RXNE flag is set
• Not waiting for transfer completion
• Confusing TXE and RXNE flags