Chip select management in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this chip select toggle code?

Consider the following embedded C code snippet managing a chip select pin. What will be the final state of the CS_PIN after execution?

Embedded C

#define CS_PIN 5
#define HIGH 1
#define LOW 0

int chip_select_state = HIGH;

void toggle_cs() {
    chip_select_state = LOW;
    // some SPI communication here
    chip_select_state = HIGH;
}

int main() {
    toggle_cs();
    return chip_select_state;
}

A 5

B 0

C 1

D Undefined behavior

💡 Hint

Think about the last assignment to chip_select_state inside toggle_cs().

The chip_select_state is set to LOW first, then back to HIGH before the function ends. So the final returned value is HIGH which is 1.

🧠 Conceptual

intermediate

Which statement best describes chip select (CS) behavior in SPI communication?

In SPI communication, what is the main purpose of the chip select (CS) line?

A It resets the SPI bus after each transfer.

B It carries the data from master to slave.

C It provides the clock signal for data transfer.

D It selects which slave device the master communicates with by enabling it.

💡 Hint

Think about how multiple devices share the SPI bus.

The chip select line is used to enable a specific slave device so it listens to the master. It does not carry clock or data signals.

🔧 Debug

advanced

Why does this chip select code cause a stuck SPI device?

Examine the code below. Why might the SPI slave device remain selected indefinitely?

Embedded C

void spi_transfer() {
    CS_PIN = 0; // activate chip select
    // send data over SPI
    // missing CS_PIN reset
}

int main() {
    spi_transfer();
    // other code
    return 0;
}

A CS_PIN is never set back to 1, so the device stays selected.

B The function spi_transfer() is missing a return statement.

C CS_PIN should be set to 2 to deselect the device.

D SPI data is not sent because CS_PIN is set to 0.

💡 Hint

Think about what happens if chip select stays low after communication.

If the chip select pin is not set back to high, the slave device remains active and may block further SPI communication.

📝 Syntax

advanced

Which option correctly toggles chip select in embedded C?

Choose the code snippet that correctly toggles the chip select pin CS_PIN from high to low and back to high.

A

CS_PIN := 0;
// SPI transfer
CS_PIN := 1;

B

CS_PIN = 0;
// SPI transfer
CS_PIN = 1;

C

CS_PIN = LOW;
// SPI transfer
CS_PIN = HIGH;

D

CS_PIN == 0;
// SPI transfer
CS_PIN == 1;

💡 Hint

Remember the assignment operator in C.

Option B uses the correct assignment operator = and proper semicolons. Option B uses invalid := syntax, Option B uses comparison ==, C misses semicolons.

🚀 Application

expert

How many times is the chip select toggled in this SPI burst?

Given the code below, how many times does the chip select pin toggle (go low then high) during the send_burst() function?

Embedded C

#define CS_PIN 10
#define LOW 0
#define HIGH 1

void send_byte(char b) {
    CS_PIN = LOW;
    // send byte over SPI
    CS_PIN = HIGH;
}

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

int main() {
    char message[3] = {0xA1, 0xB2, 0xC3};
    send_burst(message, 3);
    return 0;
}

A 3

B 1

C 6

D 0

💡 Hint

Count how many times send_byte is called and how many toggles happen per call.

The chip select toggles once per byte sent. Since 3 bytes are sent, it toggles 3 times.

Practice

1.

What is the main purpose of chip select (CS) in embedded systems?

easy

A. To enable communication with a specific device on a shared bus

B. To increase the clock speed of the microcontroller

C. To power the device on and off

D. To reset the microcontroller

Solution

1. Step 1: Understand chip select role

   Chip select is used to choose which device on a shared communication bus is active and can communicate.

2. Step 2: Eliminate unrelated options

   Increasing clock speed, powering devices, or resetting microcontrollers are not functions of chip select.

3. Final Answer:

   To enable communication with a specific device on a shared bus -> Option A

4. Quick Check:

   Chip select = Enable device communication [OK]

Hint: Chip select activates one device at a time on the bus [OK]

Common Mistakes:

• Confusing chip select with power control
• Thinking chip select changes clock speed
• Assuming chip select resets devices

2.

Which of the following is the correct way to activate a chip select pin in embedded C?

void activateCS() {
    // Assume CS_PIN is defined
    // Which line correctly activates the chip select?
    ?
}

easy

A. GPIO_WritePin(CS_PIN, GPIO_PIN_RESET);

B. GPIO_ReadPin(CS_PIN);

C. GPIO_TogglePin(CS_PIN);

D. GPIO_WritePin(CS_PIN, GPIO_PIN_SET);

Solution

1. Step 1: Recall chip select logic

   Chip select is usually active LOW, so setting the pin to RESET (LOW) activates it.

2. Step 2: Analyze options

   Setting pin HIGH (SET) deactivates chip select; toggling or reading pin does not activate it.

3. Final Answer:

   GPIO_WritePin(CS_PIN, GPIO_PIN_RESET); -> Option A

4. Quick Check:

   Active LOW means RESET activates CS [OK]

Hint: Active chip select pin is set LOW (RESET) [OK]

Common Mistakes:

• Setting chip select pin HIGH to activate
• Using toggle instead of explicit set/reset
• Reading pin instead of writing to it

3.

What will be the output of the following code snippet controlling chip select pins?

int cs_state = 1; // 1 means HIGH (inactive)

void selectDevice() {
    cs_state = 0; // Activate chip select (LOW)
}

void deselectDevice() {
    cs_state = 1; // Deactivate chip select (HIGH)
}

int main() {
    selectDevice();
    if (cs_state == 0) {
        printf("Device selected\n");
    } else {
        printf("Device not selected\n");
    }
    deselectDevice();
    if (cs_state == 1) {
        printf("Device deselected\n");
    }
    return 0;
}

medium

A. Device not selected\nDevice not deselected\n

B. Device not selected\nDevice deselected\n

C. Device selected\nDevice not deselected\n

D. Device selected\nDevice deselected\n

Solution

1. Step 1: Trace selectDevice call

   selectDevice sets cs_state to 0 (LOW), so first if prints "Device selected".

2. Step 2: Trace deselectDevice call

   deselectDevice sets cs_state to 1 (HIGH), so second if prints "Device deselected".

3. Final Answer:

   Device selected\nDevice deselected\n -> Option D

4. Quick Check:

   cs_state 0 then 1 prints selected then deselected [OK]

Hint: LOW means selected, HIGH means deselected [OK]

Common Mistakes:

• Confusing HIGH and LOW states
• Not updating cs_state before checking
• Misreading the if conditions

4.

Identify the error in the following chip select control code and choose the correct fix:

void activateCS() {
    GPIO_WritePin(CS_PIN, GPIO_PIN_SET); // supposed to activate chip select
}

void communicate() {
    activateCS();
    // communication code here
    GPIO_WritePin(CS_PIN, GPIO_PIN_SET); // deactivate chip select
}

medium

A. Remove activateCS() call because chip select is always active

B. Change deactivate line to GPIO_PIN_RESET to deactivate chip select

C. Change activateCS() to set pin LOW (GPIO_PIN_RESET) to activate chip select

D. Use GPIO_TogglePin instead of GPIO_WritePin for activation

Solution

1. Step 1: Understand chip select logic

   Chip select is active LOW, so activating means setting pin LOW (RESET), not HIGH (SET).

2. Step 2: Identify error and fix

   activateCS incorrectly sets pin HIGH; it should set pin LOW to activate chip select.

3. Final Answer:

   Change activateCS() to set pin LOW (GPIO_PIN_RESET) to activate chip select -> Option C

4. Quick Check:

   Activate CS = set LOW, not HIGH [OK]

Hint: Activate CS by setting pin LOW, not HIGH [OK]

Common Mistakes:

• Activating chip select by setting pin HIGH
• Confusing activate and deactivate pin states
• Using toggle instead of explicit set/reset

5.

You have two SPI devices sharing the same bus. How should you manage chip select pins to communicate with device 1 without interference?

// Device 1 CS pin: CS1_PIN
// Device 2 CS pin: CS2_PIN

void communicateWithDevice1() {
    // Fill in the correct chip select control sequence
    ?
    // SPI communication code here
    ?
}

hard

A. Set both CS1_PIN and CS2_PIN LOW before communication; then set both HIGH after

B. Set CS1_PIN LOW, set CS2_PIN HIGH before communication; then set CS1_PIN HIGH after

C. Set CS1_PIN HIGH, set CS2_PIN LOW before communication; then set CS2_PIN HIGH after

D. Do not control chip select pins; SPI devices auto-select

Solution

1. Step 1: Understand chip select for multiple devices

   Only one device's chip select should be LOW (active) at a time to avoid bus conflicts.

2. Step 2: Apply correct pin control

   Set device 1 CS LOW to activate it, device 2 CS HIGH to deactivate it, then after communication set device 1 CS HIGH.

3. Final Answer:

   Set CS1_PIN LOW, set CS2_PIN HIGH before communication; then set CS1_PIN HIGH after -> Option B

4. Quick Check:

   Only one CS LOW at a time to avoid conflicts [OK]

Hint: Only one chip select LOW at a time during communication [OK]

Common Mistakes:

• Activating both devices simultaneously
• Not deactivating other device's chip select
• Assuming SPI auto-selects devices