SPI data transfer sequence in Embedded C - Step-by-Step Execution

Concept Flow - SPI data transfer sequence

Start SPI Transfer

↓

Set CS Low (Select Slave)

↓

Load Data to SPI Data Register

↓

Wait for Transfer Complete Flag

↓

Read Received Data from SPI Data Register

↓

Set CS High (Deselect Slave)

↓

End SPI Transfer

This flow shows the steps of sending and receiving data over SPI: selecting the slave, sending data, waiting for completion, reading data, and deselecting the slave.

Execution Sample

Embedded C

CS_LOW();
SPI_DR = data_out;
while(!(SPI_SR & SPI_SR_TXE));
received = SPI_DR;
CS_HIGH();

This code sends one byte over SPI by selecting the slave, writing data, waiting for transmit complete, reading received data, and deselecting the slave.

Execution Table

Step	Action	SPI_SR (Status Register)	SPI_DR (Data Register)	CS Pin State	Result
1	CS_LOW() called	0x02	0x00	LOW	Slave selected, ready to send
2	SPI_DR = data_out (0x3A)	0x00	0x3A	LOW	Data loaded to send register
3	Wait for SPI_SR_TXE flag	0x02 (TXE set)	0x3A	LOW	Transmit buffer empty, transfer done
4	Read SPI_DR	0x02	0x5C	LOW	Received data 0x5C read
5	CS_HIGH() called	0x02	0x5C	HIGH	Slave deselected, transfer complete

💡 CS pin set HIGH, transfer sequence finished

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
SPI_SR	0x02	0x00	0x02	0x02	0x02
SPI_DR	0x00	0x3A	0x3A	0x5C	0x5C
CS Pin	HIGH	LOW	LOW	LOW	HIGH
received	undefined	undefined	undefined	0x5C	0x5C

Key Moments - 3 Insights

Why do we set CS pin LOW before sending data?

Setting CS LOW selects the slave device so it listens to SPI communication, as shown in step 1 of the execution_table.

What does waiting for the TXE flag mean?

Waiting for TXE means waiting until the transmit buffer is empty and data is sent, indicated by SPI_SR having the TXE bit set in step 3.

Why do we read SPI_DR after the transfer?

SPI is full-duplex; reading SPI_DR gets the data received from the slave during transmission, as done in step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the CS pin state after step 3?

A HIGH

B LOW

C Undefined

D Toggling

💡 Hint

Check the 'CS Pin State' column at step 3 in execution_table.

At which step does the SPI_SR_TXE flag become set?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'SPI_SR' values in execution_table to find when TXE (0x02) appears.

If CS_HIGH() was called before reading SPI_DR, what would happen?

A SPI_SR_TXE flag would never set

B Slave might ignore the read, causing wrong data

C Data would still be read correctly

D SPI_DR would reset to zero

💡 Hint

Refer to key_moments about CS pin role and step 5 in execution_table.

Concept Snapshot

SPI Data Transfer Sequence:
1. Set CS LOW to select slave
2. Load data to SPI data register
3. Wait for TXE flag (transfer complete)
4. Read received data from SPI data register
5. Set CS HIGH to deselect slave
SPI is full-duplex: send and receive happen together.

Full Transcript

This visual trace shows the SPI data transfer sequence in embedded C. First, the chip select (CS) pin is set LOW to select the slave device. Then, data is loaded into the SPI data register (SPI_DR). The program waits until the transmit buffer empty (TXE) flag in the SPI status register (SPI_SR) is set, indicating the transfer is complete. Next, the received data is read from SPI_DR. Finally, the CS pin is set HIGH to deselect the slave and end the transfer. Variables like SPI_SR, SPI_DR, CS pin state, and received data change step-by-step as shown in the execution table and variable tracker. Key moments clarify why CS must be LOW during transfer, the meaning of the TXE flag, and why reading SPI_DR is necessary. The quiz tests understanding of pin states, flags, and sequence order. This sequence is essential for communicating with SPI devices in embedded systems.

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