SPI Mode 0 vs Mode 3 Explained: Clock Polarity, Phase, and Wiring Guide

The Direct Answer: Which SPI Mode Should You Use?

If you are wiring up a new sensor, display, or memory chip and the datasheet is missing or unclear, default to SPI Mode 0. In the Arduino framework, this is SPI_MODE0; in ESP-IDF, it is SPI_MODE_0. Mode 0 (Clock Polarity = 0, Clock Phase = 0) is the industry standard for the vast majority of 3.3V and 5V peripherals, including the BME280 environmental sensor, MAX7219 LED drivers, and standard SD cards.

Only switch to SPI Mode 3 (CPOL = 1, CPHA = 1) if the silicon datasheet explicitly mandates it, which is common in certain Analog Devices ADCs and older flash memory chips like the W25Q128 when operated at high clock speeds. Modes 1 and 2 are exceptionally rare in modern hobbyist and commercial embedded design and should only be used if strictly specified.

Bus Mechanics: SPI vs I2C vs UART at the Physical Layer

Before diving into clock edges, you need to know why you are choosing SPI over the alternatives. SPI trades wiring complexity for raw speed and simplicity at the silicon level. Unlike I2C, SPI does not use open-drain lines, meaning it avoids the bandwidth-limiting pull-up resistor RC time constants.

Decoding SPI Modes: CPOL and CPHA Explained

The Serial Peripheral Interface relies on two timing parameters to synchronize data between the master (your ESP32 or Arduino) and the slave (the sensor). Misunderstanding these is the root cause of 90% of SPI debugging headaches.

• CPOL (Clock Polarity): Dictates the idle state of the clock (SCK) line when no data is being transferred. CPOL=0 means the clock idles LOW. CPOL=1 means the clock idles HIGH.
• CPHA (Clock Phase): Dictates which edge of the clock pulse the data is sampled on. CPHA=0 means data is sampled on the leading (first) edge. CPHA=1 means data is sampled on the trailing (second) edge.

According to the Analog Devices SPI Interface Guide, combining these yields four distinct modes. In Mode 0, the clock idles low, and data is captured on the rising edge. In Mode 3, the clock idles high, and data is captured on the falling edge. Notice that in both Mode 0 and Mode 3, the data is sampled on the opposite edge of the idle state, which provides the most stable setup and hold times for the internal flip-flops of the silicon.

Physical Wiring and the Pull-Up Trap

Unlike I2C, SPI uses push-pull drivers for MOSI, MISO, and SCK. You do not need pull-up resistors on the data or clock lines. Adding 4.7k pull-ups to SCK or MOSI will only increase rise times and limit your maximum baud rate.

However, the Chip Select (CS / SS) line is a massive point of failure in DIY builds. The CS line is active-low. If the CS line is left floating while your ESP32 boots up, the ESP32's GPIO pins will momentarily glitch, accidentally activating the SPI slave. This can cause the slave to drive the MISO line while the ESP32 is trying to use that same pin for its internal boot-strapping sequence, resulting in a boot-loop or bricked boot sequence.

For 5V sensors on a 3.3V ESP32, use a dedicated level shifter like the TXS0108E or a simple CD4050 non-inverting buffer. Avoid using resistor voltage dividers for SPI SCK lines; the parasitic capacitance of the resistors will round off the clock edges, causing phase shifts that mimic a wrong SPI mode setting.

Debugging the Bus: Sniffing and Fixing Classic Failures

When your SPI device returns garbage data, do not blindly change the SPI mode. Follow this diagnostic path using a cheap 24MHz 8-channel USB logic analyzer (running Sigrok/PulseView) or a Saleae Logic Pro.

To visually confirm the mode, hook your logic analyzer to SCK and MOSI. Trigger on the falling edge of CS. In Mode 0, the first SCK pulse should rise from a low baseline. If the baseline is high before the first pulse, you are looking at Mode 2 or 3. The Espressif ESP-IDF SPI Master Documentation provides excellent timing diagrams for verifying these edges natively on their hardware.

Minimal Working Exchange: ESP32 to MAX31855

The MAX31855 thermocouple amplifier is a classic SPI device. It is read-only (MISO only, no MOSI required) and operates strictly in Mode 0 or Mode 1 depending on the exact timing of the CS drop. We will configure it for Mode 0, which is standard for the Adafruit and SparkFun breakout boards.

Wiring Table

Arduino Framework Code

#include <SPI.h>

// Pin definitions for ESP32 VSPI hardware bus
#define MAX31855_CS   5
#define MAX31855_MISO 19
#define MAX31855_SCK  18

// We use the hardware SPI instance (VSPI on ESP32)
SPIClass * vspi = NULL;

void setup() {
  Serial.begin(115200);
  delay(1000); // Allow serial monitor to connect

  // Initialize CS pin as output and set HIGH (deselect)
  pinMode(MAX31855_CS, OUTPUT);
  digitalWrite(MAX31855_CS, HIGH);

  // Initialize the VSPI bus with explicit pin mapping
  vspi = new SPIClass(VSPI);
  vspi->begin(MAX31855_SCK, MAX31855_MISO, -1, MAX31855_CS); // MOSI is -1 (unused)
  
  // Set the SPI Mode and Speed
  // MAX31855 requires Mode 0 (or 1) and max 5MHz clock
  vspi->setDataMode(SPI_MODE0);
  vspi->setBitOrder(MSBFIRST);
  
  Serial.println("SPI Initialized: Mode 0, 4MHz");
}

void loop() {
  // Drop CS low to start transaction
  digitalWrite(MAX31855_CS, LOW);
  
  // Begin transaction at 4MHz
  vspi->beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));
  
  // Read 32 bits from the MAX31855
  uint32_t rawData = 0;
  for (int i = 0; i < 4; i++) {
    rawData <<= 8;
    rawData |= vspi->transfer(0x00); // Send dummy byte to clock in data
  }
  
  vspi->endTransaction();
  digitalWrite(MAX31855_CS, HIGH);

  // Check for fault bits (Bit 16 is open circuit, 17 is short to GND, 18 is short to VCC)
  if (rawData & 0x7) {
    Serial.print("Fault detected: 0x");
    Serial.println(rawData & 0x7, HEX);
  } else {
    // Extract 14-bit temperature (Bits 31 down to 18)
    int32_t tempRaw = (rawData >> 18) & 0x3FFF;
    
    // Handle negative temperatures (sign extension)
    if (tempRaw & 0x2000) {
      tempRaw |= 0xFFFFC000; 
    }
    
    float tempC = tempRaw * 0.25;
    Serial.print("Thermocouple Temp: ");
    Serial.print(tempC);
    Serial.println(" C");
  }

  delay(1000);
}

This code explicitly defines the hardware SPI pins, avoiding the common trap of using software bit-banging which introduces jitter that can violate the MAX31855's tight timing requirements. By forcing SPI_MODE0 inside the SPISettings object, you ensure the ESP32's SPI peripheral configures the correct CPOL and CPHA registers before the first clock edge is ever generated. For further reading on Arduino SPI implementation details, refer to the official Arduino SPI Reference.