43. Multi-Master SPI Communication

We are using the ESP32 DevKitC v4 development board and programming it using the Arduino IDE.

• Before uploading, make sure to select “ESP32 Dev Module” as the board to ensure correct settings and compatibility.

Solution of the given task

1. ESP32 as Master 1
2. ESP32 as Master 2

A) ESP32 as Master 1

Circuit Connection 

• Interfacing of a push button switch
  • GPIO pin 27 → Increment Switch
  • GPIO pin 14 → Reset Switch
• Interface Master 1 SPI pins to the slave SD card and Master 2 SPI pins.
  • GPIO PIN 18 → SCK
  • GPIO PIN 19 → MISO
  • GPIO PIN 23 → MOSI
  • GPIO PIN 5 → CS/SS

Circuit Connection

Firmware Implementation

In the ESP32 Master 1 codes, the SPI.h library is used for SPI communication.

Master 1 Code

#include <Arduino.h>
#include <SPI.h>
#include <SD.h>

// ESP32 VSPI Pins
#define CS_PIN 5     // Chip Select for SD card
#define SCK_PIN 18   // SPI Clock
#define MISO_PIN 19  // Master In Slave Out
#define MOSI_PIN 23  // Master Out Slave In

// Button Pins
#define SWITCH_INC 15  // Increment button (active LOW)
#define SWITCH_RST 4   // Reset button (active LOW)
#define DEBOUNCE_DELAY 50

// Globals
uint8_t counter = 0;
unsigned long lastDebounceTime[2] = { 0, 0 };
uint8_t lastButtonState[2] = { HIGH, HIGH };
uint8_t buttonState[2] = { HIGH, HIGH };
uint8_t switchPins[2] = { SWITCH_INC, SWITCH_RST };
const char* FILE_NAME = "/count.txt";  // SD file name

SPIClass spi(VSPI);  // Use VSPI hardware SPI bus

// Function Declarations
void enableSPI();
void disableSPI();
void initSDCard();
uint8_t readCounterFromSD();
void writeCounterToSD(uint8_t count);
bool isButtonPressed(uint8_t switchIndex);

// Setup
void setup() {
  Serial.begin(115200);
  delay(200);
  Serial.println("\n[ESP32] Counter + SD Card");

  for (uint8_t i = 0; i < 2; i++) {
    pinMode(switchPins[i], INPUT_PULLUP);
  }

  //counter = readCounterFromSD();
  Serial.print("Initial counter value: ");
  Serial.println(counter);
}

// Main Loop
void loop() {
  // Increment counter
  if (isButtonPressed(0)) {
    Serial.println("\nIncrement button pressed.");
    counter = readCounterFromSD();
    Serial.print("Initial counter value: ");
    Serial.println(counter);
    counter++;
    writeCounterToSD(counter);
    Serial.print("Counter incremented to ");
    Serial.println(counter);
  }

  // Reset counter
  if (isButtonPressed(1)) {
    Serial.println("\nReset button pressed.");
    counter = 0;
    writeCounterToSD(counter);
    Serial.println("Counter reset to 0.");
  }
}

// SD Card Functions
uint8_t readCounterFromSD() {
  uint8_t storedCounter = 0;
  initSDCard();

  if (SD.exists(FILE_NAME)) {
    File file = SD.open(FILE_NAME, FILE_READ);
    if (file) {
      storedCounter = file.parseInt();
      file.close();
      Serial.println("Counter read from SD card.");
    } else {
      Serial.println("Error: Failed to read file.");
    }
  } else {
    Serial.println("No counter file found. Starting with counter = 0.");
  }

  disableSPI();
  return storedCounter;
}

void writeCounterToSD(uint8_t count) {
  initSDCard();

  if (SD.exists(FILE_NAME)) {
    SD.remove(FILE_NAME);
    Serial.println("Old counter file deleted.");
  }

  File file = SD.open(FILE_NAME, FILE_WRITE);
  if (file) {
    file.print(count);
    file.close();
    Serial.println("Counter updated on SD card.");
  } else {
    Serial.println("Error: Failed to write to SD card.");
  }

  disableSPI();
}

void initSDCard() {
  enableSPI();
  Serial.println("SD card initializing...");
  while (!SD.begin(CS_PIN, spi)) {
    Serial.print(".");
    delay(1000);
  }
  Serial.println("\nSD card initialized.");
}

// SPI Management
void enableSPI() {
  Serial.println("Enabling SPI...");
  Serial.println("Waiting for free the SPI bus. ");
  // while (!digitalRead(CS_PIN))  // Wait until the chip select pin is LOW
  // {
  //   Serial.print(".");
  //   delay(1000);
  // }
  spi.begin(SCK_PIN, MISO_PIN, MOSI_PIN, CS_PIN);  // VSPI on ESP32
  pinMode(CS_PIN, OUTPUT);
  digitalWrite(CS_PIN, HIGH);
  Serial.println("SPI Enabled.");
}

void disableSPI() {
  SD.end();
  spi.end();

  pinMode(MOSI_PIN, INPUT);
  pinMode(MISO_PIN, INPUT);
  pinMode(SCK_PIN, INPUT);
  pinMode(CS_PIN, INPUT);

  Serial.println("SPI Disabled (pins in Hi-Z).");
}

// Debounce
bool isButtonPressed(uint8_t switchIndex) {
  uint8_t pin = switchPins[switchIndex];
  int reading = digitalRead(pin);

  if (reading != lastButtonState[switchIndex]) {
    lastDebounceTime[switchIndex] = millis();
  }
  lastButtonState[switchIndex] = reading;

  if ((millis() - lastDebounceTime[switchIndex]) > DEBOUNCE_DELAY) {
    if (reading != buttonState[switchIndex]) {
      buttonState[switchIndex] = reading;
      if (buttonState[switchIndex] == LOW) {
        return true;
      }
    }
  }
  return false;
}

Code Explanation

Setup

• Serial starts at 115200 baud for debugging.
• Two buttons:
  • SWITCH_INC (GPIO 27) → increment counter.
  • SWITCH_RST (GPIO 14) → reset counter.
     Both use INPUT_PULLUP (active LOW).
• VSPI (pins: SCK 18, MISO 19, MOSI 23, CS 5) used for SD card communication.
• On startup → reads /count.txt from SD → loads saved counter (defaults to 0).

Loop

• If Increment button pressed → counter ++ → write new value to SD.
• If Reset button pressed → counter = 0 → update SD file.
• Each action prints status to Serial Monitor.

SD Card Operations

• readCounterFromSD() → mounts SD, reads integer from /count.txt, returns 0 if missing.
• writeCounterToSD() → deletes old file, writes updated counter value, then unmounts.
• Ensures data is saved persistently across resets.

SPI Management

• enableSPI() → initialises VSPI bus, sets CS HIGH (idle), prepares pins for communication.
• disableSPI() → ends SD & SPI sessions and sets SPI pins to Hi-Z (INPUT) to prevent bus conflicts.

Button Debounce

• isButtonPressed() → checks each button separately with 50 ms debounce.
• Detects a stable LOW press only once per button activation.

B) ESP32 as Master 2

Circuit Connection 

• Interfacing of a push button switch
  • GPIO pin 27 → Count Read Switch
• Interface Master 2 SPI pins to the slave SD card and Master 1 SPI pins.
  • GPIO PIN 18 → SCK
  • GPIO PIN 19 → MISO
  • GPIO PIN 23 → MOSI
  • GPIO PIN 5 → CS/SS
• Connect Master 1 and Master 2 GPIO pin 4 through a 4.7KΩ pull-up resistor.

Circuit Connection

Firmware Implementation

In the ESP32 Master 2 code, the SPI.h library is used for SPI communication.

Master 2 Code 

#include <Arduino.h>
#include <SPI.h>
#include <SD.h>

//  ESP32 VSPI Pins
#define CS_PIN 5     // Chip Select for SD card
#define SCK_PIN 18   // SPI Clock
#define MISO_PIN 19  // Master In Slave Out
#define MOSI_PIN 23  // Master Out Slave In

//  Button
#define SWITCH_PIN 15  // Button input pin (active LOW)
#define DEBOUNCE_DELAY 50

//  Variables
uint8_t counter = 0;
unsigned long lastDebounceTime = 0;
uint8_t lastButtonState = HIGH;
uint8_t buttonState = HIGH;

const char* FILE_NAME = "/count.txt";  // File used to store counter

SPIClass spi(VSPI);  // Use VSPI hardware SPI bus

//  Setup
void setup() {
  Serial.begin(115200);
  delay(200);
  Serial.println("\n[ESP32] SD Card Counter Reader");

  pinMode(SWITCH_PIN, INPUT_PULLUP);

  // counter = readCounterFromSD();  // Read counter from SD at startup
  // Serial.print("Counter value: ");
  // Serial.println(counter);
}

//  Loop
void loop() {
  if (isButtonPressed()) {  // Check button with debounce
    Serial.println("\nRead button pressed.");
    uint8_t count = readCounterFromSD();  // Read counter from SD
    Serial.print("Stored count is: ");
    Serial.println(count);
  }
}

//  Read counter value from SD
uint8_t readCounterFromSD() {
  uint8_t storedCounter = 0;
  initSDCard();

  if (SD.exists(FILE_NAME)) {
    File file = SD.open(FILE_NAME, FILE_READ);
    if (file) {
      storedCounter = file.parseInt();
      file.close();
      Serial.println("Counter read from SD card.");
    } else {
      Serial.println("Error: Failed to read file.");
    }
  } else {
    Serial.println("No counter file found. Starting with counter = 0.");
  }

  disableSPI();
  return storedCounter;
}

//  Initialize SD card
void initSDCard() {
  enableSPI();

  Serial.println("SD card initializing...");
  while (!SD.begin(CS_PIN, spi)) {
    Serial.print(".");
    delay(1000);
  }
  Serial.println("\nSD card initialized.");
}

//  Enable SPI
void enableSPI() {
  Serial.println("Enabling SPI bus...");
  Serial.println("Waiting for free the SPI bus. ");
  while (!digitalRead(CS_PIN))  // Wait until the chip select pin is LOW
  {
    Serial.print(".");
    delay(1000);
  }
  spi.begin(SCK_PIN, MISO_PIN, MOSI_PIN, CS_PIN);  // ESP32 VSPI setup

  pinMode(CS_PIN, OUTPUT);
  digitalWrite(CS_PIN, HIGH);
  Serial.println("SPI Enabled.");
}

//  Disable SPI
void disableSPI() {
  SD.end();
  spi.end();

  pinMode(MOSI_PIN, INPUT);
  pinMode(MISO_PIN, INPUT);
  pinMode(SCK_PIN, INPUT);
  pinMode(CS_PIN, INPUT);

  Serial.println("SPI Disabled (pins set to Hi-Z).");
}

//  Debounce function
bool isButtonPressed() {
  int reading = digitalRead(SWITCH_PIN);

  if (reading != lastButtonState) {
    lastDebounceTime = millis();
  }
  lastButtonState = reading;

  if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY) {
    if (reading != buttonState) {
      buttonState = reading;
      if (buttonState == LOW) {
        return true;  // valid press
      }
    }
  }
  return false;
}

Code Explanation

Setup

• Serial starts at 115200 baud for debugging.
• Button (GPIO 27) set as INPUT_PULLUP — active LOW.
• Creates VSPI bus (SCK 18, MISO 19, MOSI 23, CS 5).
• On startup, calls readCounterFromSD() → initialises SD, reads /count.txt, prints stored counter.

Loop

• Checks the button using isButtonPressed() with 50 ms debounce.
• When pressed, → reads counter from SD again and prints it.

SD & SPI Handling

• initSDCard() → enables SPI, retries SD.begin() until card mounts.
• readCounterFromSD() → opens /count.txt, reads integer value, defaults to 0 if missing.
• disableSPI() → ends SPI, sets pins to Hi-Z (INPUT) to avoid bus conflicts.

Button Debounce

• Confirms a stable LOW press once every 50 ms, filters noise, and returns true only once per press.

We are using the Arduino UNO development board and programming it using the Arduino IDE.

• Before uploading, make sure to select “Arduino UNO” as the board to ensure correct settings and compatibility.

In both Arduino UNO master and slave codes, the SPI.h library is used for SPI communication.

SPI Pins Of Arduino UNO

• SCK → 13
• MISO → 12
• MOSI → 11
• SS → 10

Solution of the given task:

1. Arduino UNO as Master 1
2. Arduino UNO as Master 2

A) Arduino UNO as a Master 1

Circuit Connection 

• Interfacing of  push button switch 
  • GPIO pin 3 → Increment Switch
  • GPIO pin 4 → Reset Switch
• Interface Master 1 SPI pins to the slave SD card and Master 2 SPI pins.
  • GPIO PIN 18 → SCK
  • GPIO PIN 19 → MISO
  • GPIO PIN 23 → MOSI
  • GPIO PIN 5 → CS/SS
• Connect Master 1 and Master 2 CS/SS through a 4.7KΩ pull-up resistor.

Circuit Connection

Firmware

As we have Master 1 and Master 2, so we have to develop two different codes.And below points, we have to take care of the codes. 

• Debouncing Logic: Ensures stable button press detection.
• SD Card Persistence: Stores the counter value even after the Arduino is powered off.
• SPI Arbitration: Ensures the SPI bus is correctly managed by enabling/disabling SPI communication as needed.
• Modular Code: Separate functions for SPI handling, SD card operations, and button debouncing make the code reusable and maintainable.

Code(Master 1)

#include <SPI.h>
#include <SD.h>

#define CS_PIN 10           
#define SWITCH_INC 3        
#define SWITCH_RST 4        
#define DEBOUNCE_DELAY 50   

uint8_t counter = 0;                                
unsigned long lastDebounceTime[2] = {0, 0};         // Last debounce time for each button
uint8_t lastButtonState[2] = {HIGH, HIGH};          // Last recorded state of each button
uint8_t buttonState[2] = {HIGH, HIGH};              // Current state of each button
uint8_t switchPins[2] = {SWITCH_INC, SWITCH_RST};   // Array to store button pins
const char* FILE_NAME = "count.txt";                // File name for storing the counter on the SD card

void setup() {
    Serial.begin(115200);  
    for (uint8_t i = 0; i < 2; i++) {
        pinMode(switchPins[i], INPUT_PULLUP);
    }

    counter = readCounterFromSD();                // Read the initial counter value from the SD card
    Serial.print("Initial counter value: ");
    Serial.println(counter);
}

void loop() {
    // Check if the increment button is pressed
    if (isButtonPressed(0)) {
        Serial.println("\nIncrement button pressed.");
        counter++;
        writeCounterToSD(counter);  // Save updated counter to SD card
        Serial.print("Counter Incremented to ");
        Serial.println(counter);
    }

    // Check if the reset button is pressed
    if (isButtonPressed(1)) {
        Serial.println("\nReset button pressed.");
        counter = 0;
        writeCounterToSD(counter);  // Save reset counter to SD card
        Serial.println("Counter reset to 0.");
    }
}

// Reads the counter value from the SD card
uint8_t readCounterFromSD() {
    uint8_t storedCounter = 0;
    initSDCard();

    // Check if the file exists on the SD card
    if (SD.exists(FILE_NAME)) {
        File file = SD.open(FILE_NAME, FILE_READ);
        if (file) {
            storedCounter = file.parseInt();  // Parse the counter value from the file
            file.close();
            Serial.println("Counter read from SD card.");
        } else {
            Serial.println("Error: Failed to read file.");
        }
    } else {
        Serial.println("No counter file found. Starting with counter = 0.");
    }

    disableSPI();
    return storedCounter;
}

// Writes the counter value to the SD card
void writeCounterToSD(uint8_t count) {
    initSDCard();  

    // Remove the existing file if it exists
    if (SD.exists(FILE_NAME)) {
        SD.remove(FILE_NAME);
        Serial.println("Old counter file deleted.");
    }

    // Create and write the new counter value to the file
    File file = SD.open(FILE_NAME, FILE_WRITE);
    if (file) {
        file.print(count);
        file.close();
        Serial.println("Counter updated on SD card.");
    } else {
        Serial.println("Error: Failed to write to SD card.");
    }

    disableSPI();
}

// Initializes the SD card
void initSDCard() {
    enableSPI();  // Enable SPI communication

    Serial.println("SD card initializing");

    while(!SD.begin(CS_PIN)){
      Serial.print(".");
      delay(1000);
    }

    Serial.println("SD card initialized.");
}

// Enables SPI communication
void enableSPI() {
    Serial.println("Waiting for free the SPI bus. ");
    while (!digitalRead(CS_PIN))  // Wait until the chip select pin is LOW
    {
      Serial.print(".");
      delay(1000);
    }
    SPI.begin();
    pinMode(CS_PIN, OUTPUT);
    pinMode(11, OUTPUT);  // MOSI pin
    pinMode(12, INPUT);   // MISO pin
    pinMode(13, OUTPUT);  // SCK pin
    digitalWrite(CS_PIN, HIGH);
    Serial.println("SPI Enabled.");
}

// Disables SPI communication by setting SPI pins to input mode and driving them low. 
// This makes the pins high impedance, effectively disconnecting the SPI interface.
void disableSPI() {
    SPI.end();
    pinMode(11, INPUT);  // MOSI pin
    pinMode(12, INPUT);  // MISO pin
    pinMode(13, INPUT);  // SCK pin
    pinMode(CS_PIN, INPUT);  
    digitalWrite(11, LOW);
    digitalWrite(12, LOW);
    digitalWrite(13, LOW);
    digitalWrite(CS_PIN, LOW);
    Serial.println("SPI Disabled.");
}

// Checks if a button is pressed with debouncing
bool isButtonPressed(uint8_t switchIndex) {
    uint8_t pin = switchPins[switchIndex];
    int reading = digitalRead(pin);

    // Check if the button state has changed
    if (reading != lastButtonState[switchIndex]) {
        lastDebounceTime[switchIndex] = millis();
    }
    lastButtonState[switchIndex] = reading;

    // Validate the button press after debounce delay
    if ((millis() - lastDebounceTime[switchIndex]) > DEBOUNCE_DELAY) {
        if (reading != buttonState[switchIndex]) {
            buttonState[switchIndex] = reading;
            if (buttonState[switchIndex] == LOW) {
                return true;  
            }
        }
    }
    return false;
}

Code Explanation (Master 1)

Setup

• Serial Communication: Starts at 115200 baud rate for debugging/logging.
• Button Pins: Configured with INPUT_PULLUP to detect button presses.
• Counter Initialization: Reads the existing counter value from the SD card or starts at 0 if no file exists.

Loop

1. Increment Button:
   • Checks if pressed using isButtonPressed(0).
   • Increments the counter and writes it to the SD card using writeCounterToSD().
2. Reset Button:
   • Checks if pressed using isButtonPressed(1).
   • Resets the counter to 0 and updates the SD card.

SPI Management

• enableSPI():
  • Waits for the SPI bus to be free (CS_PIN HIGH).
  • Configures SPI pins (MOSI, MISO, SCK) and starts SPI communication.
  • Drives CS_PIN HIGH to indicate communication readiness.
• disableSPI():
  • Stops SPI communication using SPI.end().
  • Configures SPI pins as INPUT and drives them LOW to make them high-impedance, effectively disconnecting the master.

SD Card Operations

• initSDCard():
  • Initializes the SD card and retries until successful, indicated by SD.begin(CS_PIN).
• readCounterFromSD():
  • Checks for count.txt on the SD card.
  • Reads the counter value from the file, or defaults to 0 if the file doesn't exist.
• writeCounterToSD():
  • Removes the existing file (if any).
  • Writes the updated counter value to the file count.txt.

Button Debouncing

• isButtonPressed():
  • Reads the button state and detects changes.
  • Verifies state stability using DEBOUNCE_DELAY (50ms).
  • Returns true when a valid button press is detected.

B) Arduino UNO as a Master 2

First, let's establish the hardware connection.

Circuit Connection 

• Interfacing of a push button switch 
  • GPIO pin 4 → Count Read Switch
• Interface Master 2 SPI pins to the slave SD card and Master 1 SPI pins.
  • GPIO PIN 13 → SCK
  • GPIO PIN 11 → MISO
  • GPIO PIN 12 → MOSI
  • GPIO PIN 10 → CS/SS
• Connect Master 1 and Master 2 CS pin through a 4.7KΩ pull-up resistor.

Circuit Connection

Code (Master 2)

#include <SPI.h>
#include <SD.h>

#define CS_PIN 10            
#define SWITCH_PIN 3         
#define DEBOUNCE_DELAY 50    

uint8_t counter = 0;                  
unsigned long lastDebounceTime = 0;   
uint8_t lastButtonState = HIGH;       
uint8_t buttonState = HIGH;        

const char* FILE_NAME = "count.txt";  // File name used to store the counter on the SD card

void setup() {
    Serial.begin(115200);
    pinMode(SWITCH_PIN, INPUT_PULLUP);

    counter = readCounterFromSD();    // Read the counter value from the SD card at startup
    Serial.print("Counter value: ");
    Serial.println(counter);
}

void loop() {
    // Check if the button is pressed 
    if (isButtonPressed()) {
        Serial.println("\nRead button pressed.");
        uint8_t count = readCounterFromSD();  // Fetch the counter value from the SD card
        Serial.print("Stored count is: ");
        Serial.println(count);
    }
}

// Reads the counter value from the SD card
uint8_t readCounterFromSD() {
    uint8_t storedCounter = 0;
    initSDCard();

    // Check if the file exists on the SD card
    if (SD.exists(FILE_NAME)) {
        File file = SD.open(FILE_NAME, FILE_READ);  // Open the file for reading
        if (file) {
            storedCounter = file.parseInt();  // Read the counter value as an integer
            file.close();
            Serial.println("Counter read from SD card.");
        } else {
            Serial.println("Error: Failed to read the file.");
        }
    } else {
        Serial.println("No counter file found. Starting with counter = 0.");
    }

    disableSPI();  
    return storedCounter;
}

// Initializes the SD card and sets up the SPI interface
void initSDCard() {
    enableSPI();  // Enable SPI communication

    Serial.println("SD card initializing");

    while(!SD.begin(CS_PIN)){
      Serial.print(".");
      delay(1000);
    }

    Serial.println("SD card initialized.");
}

// Enables SPI communication
void enableSPI() {
    Serial.println("Waiting for free the SPI bus. ");
    while (!digitalRead(CS_PIN))  // Wait until the chip select pin is LOW
    {
      Serial.print(".");
      delay(1000);
    }
    SPI.begin();
    pinMode(CS_PIN, OUTPUT);
    pinMode(11, OUTPUT);  // MOSI pin
    pinMode(12, INPUT);   // MISO pin
    pinMode(13, OUTPUT);  // SCK pin
    digitalWrite(CS_PIN, HIGH);
    Serial.println("SPI Enabled.");
}

// Disables SPI communication by setting SPI pins to input mode and driving them low. 
// This makes the pins high impedance, effectively disconnecting the SPI interface.
void disableSPI() {
    SPI.end();
    pinMode(11, INPUT);  // MOSI pin
    pinMode(12, INPUT);  // MISO pin
    pinMode(13, INPUT);  // SCK pin
    pinMode(CS_PIN, INPUT);

    digitalWrite(11, LOW);
    digitalWrite(12, LOW);
    digitalWrite(13, LOW);
    digitalWrite(CS_PIN, LOW);
    Serial.println("SPI Disabled.");
}

// Checks if the button is pressed with debounce logic
bool isButtonPressed() {
    int reading = digitalRead(SWITCH_PIN);  // Read the current button state

    // Detect button state change
    if (reading != lastButtonState) {
        lastDebounceTime = millis();  // Update debounce timer
    }
    lastButtonState = reading;

    // Validate button press after debounce delay
    if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY) {
        if (reading != buttonState) {
            buttonState = reading;

            // Return true if the button is pressed
            if (buttonState == LOW) {
                return true;
            }
        }
    }

    return false;  // Return false if no valid press is detected
}

Code Explanation (Master 2)

Loop

• Button Check: If the button is pressed (isButtonPressed()), it reads and prints the counter value from the SD card.

SPI Management

• enableSPI(): Waits for the SPI bus to be free, configures SPI pins, and starts SPI communication.
• disableSPI():
  • Stops SPI communication using SPI.end().
  • Configures SPI pins as INPUT and drives them LOW to make them high-impedance, effectively disconnecting the master.

SD Card Operations

• initSDCard(): Initializes the SD card and retries until successful.
• readCounterFromSD(): Reads the counter value from count.txt or initializes it to 0 if the file doesn't exist.

Button Debouncing

isButtonPressed(): Debounces the button with a delay of 50ms and detects valid presses.

Output

Hardware Setup

Master 1 Serial Monitor Output

Master 2 Serial Monitor Output

Video