41. SPI Dice Roll

Key Peripherals Used:

• SPI2: For SPI communication between the master and the slave.
• GPIO: For connecting the push-button switch and LED.
• USART2: For serial communication with a serial terminal to display messages.

Hardware Connection

Common SPI Lines

• SCK ↔ PB13 (SPI2_SCK), the master drives the clock.
• MOSI ↔ PB15 (SPI2_MOSI), master-to-slave data.
• MISO ↔ PB14 (SPI2_MISO), slave-to-master data.
• NSS/CS ↔ PB12 (SPI2_NSS), driven by master, connected to slave NSS or as a GPIO-controlled chip-select.
• GND: Common ground between master and slave.
• 3.3V: Optional if powering both boards from one source; otherwise, power independently and share GND only.

Master Board (NUCLEO-F103RB)

• Push-button: PA0 (A0) configured as input with pull-up.
• SPI2 pins:
  • PB13: SCK
  • PB14: MISO
  • PB15: MOSI
  • PB12: NSS/CS (GPIO output, controlled low during transfers)

Circuit Diagram

Firmware Implementation

STM32 as a Master

Project Setup in STM32CubeIDE

1. Create a Project
   • Open STM32CubeIDE, start a new project, and select the NUCLEO-F103RB board.
2. Basic Configuration (via CubeMX inside CubeIDE)
   • Clock: Use the default HSI oscillator with PLL enabled (as configured in SystemClock_Config).
   • GPIO: Enable clocks for PORTA, PORTB, PORTC, and PORTD.
     • Push-Button: Set GPIO PA0 as a GPIO Input Pull-Up
   • SPI2 Configuration:
     • Mode: Full Duplex Master (SPI_MODE_MASTER)
     • Data Line: 2-line full duplex (SPI_DIRECTION_2LINES) → supports both MOSI and MISO
     • Data Size: 8-bit (SPI_DATASIZE_8BIT)
     • Clock Polarity (CPOL): High (SPI_POLARITY_HIGH) → Clock idle state is HIGH
     • Clock Phase (CPHA): Data sampled on first edge (SPI_PHASE_1EDGE)
     • NSS (Slave Select): Software-controlled (SPI_NSS_SOFT)
     • Baud Rate: Prescaler 32 (SPI_BAUDRATEPRESCALER_32)
     • Data Order: MSB first (SPI_FIRSTBIT_MSB)
     • TI Mode: Disabled (SPI_TIMODE_DISABLE)
     • CRC Calculation: Disabled (SPI_CRCCALCULATION_DISABLE)
     • CRC Polynomial: 10 (not used since CRC is disabled)
   • Interrupt: Enable SPI2 Global Interrupt in NVIC.
   • USART2: Configure for asynchronous communication, default settings (115200 baud).
3. Code Generation
   • CubeMX will automatically generate all the startup code, including:
     • HAL_Init() → Initializes HAL and system tick.
     • SystemClock_Config() → Configures system clock (HSI + PLL).
     • MX_GPIO_Init() → Initializes GPIO ports.
     • MX_USART2_UART_Init() → Configures UART2.
     • MX_SPI2_Init() → Configures I2C1.
   • This code sets up the hardware and prepares the project for firmware development, so we only need to add our application logic in the user code sections

Hardware Connection 

Master ( ESP32 ) interfacing with a slave microcontroller

• Master SCK (pin 18) → slave SCK
• Master MISO (pin 19) → slave MISO
• Master MOSI (pin 23) → slave MOSI
• Master SS (pin  5) → slave SS
• Master GND → slave GND

Circuit Diagram

Firmware

Code(Master) 

#include <SPI.h>  // Include SPI library

// Pin Definitions
#define BUTTON_PIN 4  // GPIO for button input
#define CS_PIN 5      // Chip Select (connect to slave CS pin)


// Button Debounce Variables
unsigned long debounce_duration = 50;  // Debounce time (ms)
int previous_button_state = HIGH;
int current_button_state = HIGH;
unsigned long last_debounce_time = 0;

// SPI Settings
// 4 MHz SPI clock, MSB first, Mode 2
SPISettings spiSettings(4000000, MSBFIRST, SPI_MODE2);

void setup() {
  Serial.begin(115200);

  // Initialize button pin with internal pull-up
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  // Initialize CS pin for SPI
  pinMode(CS_PIN, OUTPUT);
  digitalWrite(CS_PIN, HIGH);  // Deselect slave initially

  // Start SPI on ESP32 VSPI bus
  SPI.begin(18, 19, 23, CS_PIN);  // SCK=18, MISO=19, MOSI=23, CS=5

  Serial.println("Click the button 🎲 to roll the dice:");
}

void loop() {
  if (debounced_button_press_check(BUTTON_PIN, LOW)) {
    byte masterReceive = 0;

    // Begin SPI communication
    SPI.beginTransaction(spiSettings);
    digitalWrite(CS_PIN, LOW);  // Select the slave

    // Send dummy byte (0) and receive response
    masterReceive = SPI.transfer(0);

    digitalWrite(CS_PIN, HIGH);  // Deselect the slave
    SPI.endTransaction();

    // Display result from slave
    if (masterReceive > 0 && masterReceive < 7) {
      Serial.print("You 🎲 rolled a ");
      Serial.print(masterReceive);
      Serial.println(" !");
    } else {
      Serial.println("Dice roller not responding properly. Check connections.");
    }
  }
}


// Debounce Function
bool debounced_button_press_check(int pin, bool expected_state) {
  int button_reading = digitalRead(pin);

  // Detect state change
  if (button_reading != previous_button_state) {
    last_debounce_time = millis();
  }
  previous_button_state = button_reading;

  // Check for stable input beyond debounce duration
  if ((millis() - last_debounce_time) > debounce_duration) {
    if (button_reading != current_button_state) {
      current_button_state = button_reading;
      if (current_button_state == expected_state) {
        return true;
      }
    }
  }
  return false;
}

Code Explanation

• SPI.begin(18, 19, 23, CS_PIN):
   Initializes SPI communication on the ESP32 VSPI bus using pins SCK (18), MISO (19), MOSI (23), and CS (5).
• SPISettings(4000000, MSBFIRST, SPI_MODE2):
   Configures SPI to operate at 4 MHz, with MSB first, and in Mode 2 (CPOL = 1, CPHA = 0) for correct clock phase and polarity.
• digitalWrite(CS_PIN, HIGH):
   Keeps the Chip Select (CS) line HIGH when idle (no communication).
   During communication, CS is pulled LOW to activate the slave.
• SPI.transfer(0):
  • Sends a dummy byte (0) to the slave and simultaneously reads the response from it.
  • In this project, the slave sends back a random number between 1 and 6 representing the dice roll.
• if (masterReceive > 0 && masterReceive < 7):
  • Validates the received data.
    If the value is within 1–6, it is treated as a valid dice roll result; otherwise, it indicates an error or an uninitialized slave.
• debounced_button_press_check(BUTTON_PIN, LOW):
  • Checks if the button has transitioned from HIGH to LOW (pressed state) with debounce protection.
  • When the button is pressed, the master sends data to the slave, receives the random number, and prints the dice result on the Serial Monitor.