SPI data transfer sequence in Embedded C - Mini Project: Build & Apply

SPI Data Transfer Sequence

📖 Scenario: You are working with a microcontroller that communicates with a sensor using SPI (Serial Peripheral Interface). You need to write a simple program that sends a byte of data to the sensor and receives a byte back.

🎯 Goal: Build a program that performs a basic SPI data transfer sequence: initialize data, set a transfer byte, perform the SPI transfer, and print the received byte.

📋 What You'll Learn

Create a variable to hold the data to send

Create a variable to hold the received data

Create a variable for the SPI status

Write a function call to perform SPI transfer

Print the received data

💡 Why This Matters

🌍 Real World

SPI is a common way microcontrollers talk to sensors, memory chips, and other devices quickly and reliably.

💼 Career

Embedded developers often write SPI communication code to interface hardware components in products like IoT devices, automotive systems, and consumer electronics.

1

DATA SETUP: Define SPI data variables

Create a uint8_t variable called data_to_send and set it to 0x3A. Also create a uint8_t variable called data_received and initialize it to 0.

Embedded C

#include 
#include 

int main() {

    // Create data_to_send and data_received variables
    // Your code here

    return 0;
}

Hint

Use uint8_t type for 8-bit data variables and assign the exact values.

2

CONFIGURATION: Define SPI status variable

Add a uint8_t variable called spi_status and initialize it to 0 to hold the SPI transfer status.

Embedded C

#include 
#include 

int main() {

    uint8_t data_to_send = 0x3A;
    uint8_t data_received = 0;

    // Create spi_status variable
    // Your code here

    return 0;
}

Hint

Define spi_status as uint8_t and set it to zero.

3

CORE LOGIC: Perform SPI data transfer

Call the function spi_transfer with data_to_send as input, assign the returned value to data_received, and set spi_status to 1 to indicate success.

Embedded C

#include 
#include 

uint8_t spi_transfer(uint8_t data) {
    // Simulate SPI transfer by returning data incremented by 1
    return data + 1;
}

int main() {

    uint8_t data_to_send = 0x3A;
    uint8_t data_received = 0;
    uint8_t spi_status = 0;

    // Perform SPI transfer and update spi_status
    // Your code here

    return 0;
}

Hint

Assign the result of spi_transfer(data_to_send) to data_received and set spi_status to 1.

4

OUTPUT: Print the received SPI data

Write a printf statement to display the text "Received data: 0x%X\n" with data_received as the value.

Embedded C

#include 
#include 

uint8_t spi_transfer(uint8_t data) {
    // Simulate SPI transfer by returning data incremented by 1
    return data + 1;
}

int main() {

    uint8_t data_to_send = 0x3A;
    uint8_t data_received = 0;
    uint8_t spi_status = 0;

    data_received = spi_transfer(data_to_send);
    spi_status = 1;

    // Print the received data
    // Your code here

    return 0;
}

Hint

Use printf with format specifier 0x%X to print the received byte in hexadecimal.

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