SPI master-slave architecture in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

SPI Master sends data to Slave

What is the output on the SPI slave's received buffer after the master sends the data array?

Embedded C

#include <stdio.h>
#include <string.h>

#define BUFFER_SIZE 5

char spi_slave_buffer[BUFFER_SIZE];

void spi_master_send(const char *data, int length) {
    // Simulate sending data to slave
    memcpy(spi_slave_buffer, data, length);
}

int main() {
    const char master_data[BUFFER_SIZE] = {'H', 'E', 'L', 'L', 'O'};
    spi_master_send(master_data, BUFFER_SIZE);
    printf("%.*s", BUFFER_SIZE, spi_slave_buffer);
    return 0;
}

A Error: Buffer overflow

B HELLO

C HELLO\0

D hello

💡 Hint

Remember that memcpy copies exactly the bytes given without adding null terminators.

The master sends the array {'H','E','L','L','O'} to the slave buffer using memcpy. The slave buffer contains exactly these 5 characters. The printf prints these 5 characters without adding a null terminator, so the output is 'HELLO'.

❓ Predict Output

intermediate

SPI Slave responds to Master request

What will be printed by the master after receiving data from the slave?

Embedded C

#include <stdio.h>

char spi_slave_data[] = {0x10, 0x20, 0x30};

void spi_slave_send(char *buffer, int length) {
    for (int i = 0; i < length; i++) {
        buffer[i] = spi_slave_data[i];
    }
}

int main() {
    char master_receive[3] = {0};
    spi_slave_send(master_receive, 3);
    printf("%02X %02X %02X", master_receive[0], master_receive[1], master_receive[2]);
    return 0;
}

A Error: Uninitialized buffer

B 0x10 0x20 0x30

C 16 32 48

D 10 20 30

💡 Hint

The printf uses %02X to print hexadecimal values without the 0x prefix.

The slave sends bytes 0x10, 0x20, 0x30 to the master buffer. The master prints them in uppercase hexadecimal without prefix, so output is '10 20 30'.

🔧 Debug

advanced

Identify the cause of SPI data corruption

This SPI master code sometimes sends corrupted data to the slave. What is the most likely cause?

Embedded C

void spi_master_send(char *data, int length) {
    for (int i = 0; i <= length; i++) {
        spi_send_byte(data[i]);
    }
}

// spi_send_byte sends one byte over SPI hardware

int main() {
    char data[] = {0x01, 0x02, 0x03};
    spi_master_send(data, 3);
    return 0;
}

A The loop uses <= length causing one extra byte to be sent, reading out of bounds

B spi_send_byte is not called inside the loop

C The data array is not initialized

D The function spi_master_send should use a while loop instead

💡 Hint

Check the loop condition carefully and how array indexing works.

The loop runs from i=0 to i<=length, which means it runs length+1 times. This causes reading data[length], which is out of bounds and may send garbage or cause corruption.

📝 Syntax

advanced

Correct SPI Slave receive function syntax

Which option correctly implements a function to receive data on SPI slave and store it in a buffer?

A

void spi_slave_receive(char *buffer, int length) {
    int i = 0;
    while (i <= length) {
        buffer[i] = spi_read_byte();
        i++;
    }
}

B

void spi_slave_receive(char buffer[], int length) {
    for (int i = 0; i <= length; i++) {
        buffer[i] = spi_read_byte();
    }
}

C

void spi_slave_receive(char *buffer, int length) {
    for (int i = 0; i < length; i++) {
        buffer[i] = spi_read_byte();
    }
}

D

void spi_slave_receive(char buffer[], int length) {
    for (int i = 1; i < length; i++) {
        buffer[i] = spi_read_byte();
    }
}

💡 Hint

Remember array indexing starts at 0 and loops should run less than length.

Option C correctly loops from 0 to length-1 and stores bytes read from spi_read_byte() into buffer. Other options either go out of bounds or skip first element.

🚀 Application

expert

Calculate SPI clock frequency divider

An SPI master runs at 16 MHz system clock. To communicate with a slave at 1 MHz SPI clock, which divider value should be set in the SPI control register if the SPI clock = system clock / (2 * (divider + 1))?

A 7

B 3

C 15

D 1

💡 Hint

Rearrange the formula: divider = (system_clock / (2 * SPI_clock)) - 1

Given SPI_clock = 1 MHz, system_clock = 16 MHz, divider = (16,000,000 / (2 * 1,000,000)) - 1 = (16 / 2) - 1 = 8 - 1 = 7. So the divider value to set is 7.

Practice

1. In SPI master-slave architecture, who controls the clock signal?

easy

A. The master device controls the clock signal.

B. The slave device controls the clock signal.

C. Both master and slave share clock control equally.

D. No clock signal is used in SPI communication.

Solution

1. Step 1: Understand SPI roles

   In SPI, the master initiates communication and controls timing.

2. Step 2: Identify clock control

   The master generates the clock signal to synchronize data transfer.

3. Final Answer:

   The master device controls the clock signal. -> Option A

4. Quick Check:

   Master controls clock = A [OK]

Hint: Master always controls clock in SPI [OK]

Common Mistakes:

• Thinking slave controls clock
• Assuming no clock is needed
• Believing clock is shared equally

2. Which of the following is the correct way to select a slave device in SPI using embedded C?

easy

A. Send a special data byte to select the slave.

B. Set the slave select (SS) pin HIGH to select the slave.

C. Toggle the clock pin to select the slave.

D. Set the slave select (SS) pin LOW to select the slave.

Solution

1. Step 1: Recall SPI slave selection method

   In SPI, the master selects a slave by pulling its SS pin LOW.

2. Step 2: Understand pin logic

   Setting SS LOW activates the slave; HIGH deselects it.

3. Final Answer:

   Set the slave select (SS) pin LOW to select the slave. -> Option D

4. Quick Check:

   SS LOW selects slave = A [OK]

Hint: SS pin LOW means slave selected [OK]

Common Mistakes:

• Setting SS HIGH to select slave
• Using clock pin to select slave
• Sending data to select slave

3. Given this embedded C code snippet for SPI master:

SPI_SS_PIN = 0; // Select slave
SPI_Write(0xA5); // Send data
SPI_SS_PIN = 1; // Deselect slave

What happens on the SPI bus during this code execution?

medium

A. The master selects the slave, sends 0xA5, then deselects the slave.

B. The slave sends 0xA5 to the master.

C. The master sends 0xA5 without selecting any slave.

D. The slave select pin stays HIGH, so no communication occurs.

Solution

1. Step 1: Analyze slave select pin changes

   Setting SPI_SS_PIN to 0 selects the slave before sending data.

2. Step 2: Understand data transmission

   SPI_Write(0xA5) sends data from master to selected slave.

3. Step 3: Deselect slave after sending

   Setting SPI_SS_PIN to 1 ends communication by deselecting slave.

4. Final Answer:

   The master selects the slave, sends 0xA5, then deselects the slave. -> Option A

5. Quick Check:

   SS LOW + send data + SS HIGH = D [OK]

Hint: SS LOW before send, HIGH after send [OK]

Common Mistakes:

• Assuming slave sends data
• Ignoring slave select pin state
• Thinking data sends without slave selected

4. Identify the error in this SPI master code snippet:

SPI_SS_PIN = 1; // Deselect slave
SPI_Write(0x3C); // Send data
SPI_SS_PIN = 0; // Select slave

medium

A. Data 0x3C is invalid for SPI communication.

B. Slave select pin is toggled correctly; no error.

C. Slave is deselected before sending data, so data won't be received.

D. SPI_Write function should be called after deselecting slave.

Solution

1. Step 1: Check slave select pin timing

   Slave is deselected (SS=1) before sending data, so slave ignores data.

2. Step 2: Correct order for SPI communication

   Slave must be selected (SS=0) before sending data to receive it.

3. Final Answer:

   Slave is deselected before sending data, so data won't be received. -> Option C

4. Quick Check:

   SS must be LOW before send = C [OK]

Hint: Select slave before sending data [OK]

Common Mistakes:

• Sending data before selecting slave
• Assuming data sends regardless of SS pin
• Misunderstanding SPI_Write timing

5. You want to communicate with two SPI slaves using one master. Which approach correctly manages slave selection in embedded C?

hard

A. Connect both slaves to the same slave select pin and set it LOW to select both.

B. Use separate slave select pins for each slave and set only one LOW at a time.

C. Toggle the clock pin rapidly to switch between slaves.

D. Send a unique data byte to select each slave without changing slave select pins.

Solution

1. Step 1: Understand multiple slave selection

   Each slave needs its own slave select pin controlled by the master.

2. Step 2: Select only one slave at a time

   Set only one slave select pin LOW to activate that slave; others stay HIGH.

3. Step 3: Avoid simultaneous selection

   Selecting multiple slaves at once causes bus conflicts and data errors.

4. Final Answer:

   Use separate slave select pins for each slave and set only one LOW at a time. -> Option B

5. Quick Check:

   Separate SS pins, one LOW at a time = B [OK]

Hint: One SS pin LOW per slave communication [OK]

Common Mistakes:

• Using one SS pin for all slaves
• Trying to select slaves by clock toggling
• Selecting multiple slaves simultaneously