SPI-Bus mit Arduino & ESP32 verstehen: Mehrere Geräte an einem Bus betreiben

Warum es SPI überhaupt gibt

Stell dir vor, jedes Modul bräuchte seine eigene Datenleitung. Ein TFT-Display, eine SD-Karte und ein RFID-Leser – schon wären zwölf Pins weg, und der Arduino Nano hätte kaum noch etwas übrig. SPI löst das elegant: Drei Leitungen werden von allen Geräten geteilt, und nur eine einzige zusätzliche Leitung pro Gerät entscheidet, wer gerade angesprochen wird.

Die vier Signale heißen:

• SCK (Serial Clock) – der Takt. Der Mikrocontroller gibt ihn vor, jedes Bit wird an einer Taktflanke übernommen.
• MOSI (Master Out, Slave In) – Daten vom Mikrocontroller zum Modul.
• MISO (Master In, Slave Out) – Daten vom Modul zurück zum Mikrocontroller.
• CS bzw. SS (Chip Select / Slave Select) – die Auswahlleitung. LOW bedeutet aktiv. Jedes Gerät bekommt einen eigenen CS-Pin.

SPI oder I2C – wann was?

Beide Busse teilen sich Leitungen zwischen mehreren Geräten, aber sie lösen unterschiedliche Probleme:

Das brauchst du

1Die Verkabelung – gemeinsam und getrennt

Der Kern des Ganzen: SCK, MOSI und MISO gehen von allen Modulen an dieselben drei Pins des Mikrocontrollers. Nur CS bekommt jeweils einen eigenen freien Digitalpin.

2SPI zu Fuß: SPI.transfer() verstehen

Bevor du fertige Bibliotheken benutzt, lohnt sich ein Blick auf die nackte Mechanik. So sieht eine SPI-Transaktion aus – und du siehst genau, wo CS auf LOW geht:

#include <SPI.h>

#define CS_GERAET 10

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

  pinMode(CS_GERAET, OUTPUT);
  digitalWrite(CS_GERAET, HIGH);   // WICHTIG: erst deaktivieren, dann SPI starten

  SPI.begin();
}

// Ein Register lesen: Adresse senden, dann Dummy-Byte schieben
uint8_t leseRegister(uint8_t adresse) {
  // 8 MHz, hoechstwertiges Bit zuerst, SPI-Modus 0
  SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
  digitalWrite(CS_GERAET, LOW);          // Geraet aktivieren

  SPI.transfer(adresse | 0x80);          // Bit 7 = Lesebefehl (geraeteabhaengig!)
  uint8_t wert = SPI.transfer(0x00);     // Dummy senden, Antwort einlesen

  digitalWrite(CS_GERAET, HIGH);         // Geraet freigeben
  SPI.endTransaction();
  return wert;
}

void schreibeRegister(uint8_t adresse, uint8_t wert) {
  SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
  digitalWrite(CS_GERAET, LOW);
  SPI.transfer(adresse & 0x7F);          // Bit 7 = 0 -> schreiben
  SPI.transfer(wert);
  digitalWrite(CS_GERAET, HIGH);
  SPI.endTransaction();
}

void loop() {
  Serial.println(leseRegister(0x00), HEX);
  delay(1000);
}

3Die vier SPI-Modi – und warum dein Modul schweigt

SPI kennt vier Betriebsarten, die sich aus zwei Bits ergeben: CPOL (Ruhepegel des Takts) und CPHA (auf welcher Flanke die Daten übernommen werden). Passt der Modus nicht, bekommst du keinen Fehler – du bekommst nur Müll oder lauter Nullen.

Steht der Modus nicht im Datenblatt, hilft brutales Ausprobieren – vier Varianten sind schnell durch:

#include <SPI.h>
#define CS_PIN 10

uint8_t testeModus(uint8_t modus, uint8_t adresse) {
  uint8_t spiModi[4] = { SPI_MODE0, SPI_MODE1, SPI_MODE2, SPI_MODE3 };
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, spiModi[modus]));
  digitalWrite(CS_PIN, LOW);
  SPI.transfer(adresse | 0x80);
  uint8_t wert = SPI.transfer(0x00);
  digitalWrite(CS_PIN, HIGH);
  SPI.endTransaction();
  return wert;
}

void setup() {
  Serial.begin(115200);
  pinMode(CS_PIN, OUTPUT);
  digitalWrite(CS_PIN, HIGH);
  SPI.begin();
  delay(500);

  // Register mit bekanntem Inhalt lesen, z.B. eine Chip-ID
  for (uint8_t m = 0; m < 4; m++) {
    Serial.print("SPI_MODE");
    Serial.print(m);
    Serial.print(" -> 0x");
    Serial.println(testeModus(m, 0x37), HEX);   // 0x37 = VersionReg beim RC522
    delay(50);
  }
}

void loop() {}

Beim RC522 liefert das Versionsregister 0x37 in der Regel 0x91 oder 0x92. Genau der Modus, bei dem ein plausibler Wert herauskommt, ist der richtige.

4Drei Geräte an einem Bus – das komplette Beispiel

Jetzt die Kür: SD-Karte, Display und RFID-Leser gleichzeitig. Der entscheidende Trick steckt in setup() – alle CS-Pins werden auf HIGH gesetzt, bevor irgendeine Bibliothek initialisiert wird:

#include <SPI.h>
#include <SD.h>
#include <MFRC522.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>

#define CS_SD    10
#define CS_TFT    9
#define CS_RFID   8
#define TFT_DC    7
#define TFT_RST   6
#define RFID_RST  5

Adafruit_ST7735 tft = Adafruit_ST7735(CS_TFT, TFT_DC, TFT_RST);
MFRC522 rfid(CS_RFID, RFID_RST);

bool sdBereit = false;

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

  // ---- ALLE Chip-Selects deaktivieren, bevor irgendetwas startet ----
  pinMode(CS_SD,   OUTPUT); digitalWrite(CS_SD,   HIGH);
  pinMode(CS_TFT,  OUTPUT); digitalWrite(CS_TFT,  HIGH);
  pinMode(CS_RFID, OUTPUT); digitalWrite(CS_RFID, HIGH);
  delay(10);

  SPI.begin();

  // ---- Display zuerst, damit du Statusmeldungen sehen kannst ----
  tft.initR(INITR_BLACKTAB);
  tft.setRotation(1);
  tft.fillScreen(ST77XX_BLACK);
  tft.setTextColor(ST77XX_WHITE);
  tft.setTextSize(1);
  tft.setCursor(4, 4);
  tft.println("SPI-Bus Demo");

  // ---- SD-Karte ----
  sdBereit = SD.begin(CS_SD);
  tft.setCursor(4, 18);
  tft.println(sdBereit ? "SD: OK" : "SD: FEHLER");
  Serial.println(sdBereit ? F("SD bereit") : F("SD nicht gefunden"));

  // ---- RFID ----
  rfid.PCD_Init();
  byte version = rfid.PCD_ReadRegister(MFRC522::VersionReg);
  tft.setCursor(4, 32);
  tft.print("RC522 v0x");
  tft.println(version, HEX);
  Serial.print(F("RC522 Version: 0x"));
  Serial.println(version, HEX);
}

void loop() {
  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) {
    delay(50);
    return;
  }

  // UID als Hex-String zusammenbauen
  String uid = "";
  for (byte i = 0; i < rfid.uid.size; i++) {
    if (rfid.uid.uidByte[i] < 0x10) uid += "0";
    uid += String(rfid.uid.uidByte[i], HEX);
  }
  uid.toUpperCase();

  Serial.print(F("Karte: "));
  Serial.println(uid);

  tft.fillRect(0, 50, 160, 40, ST77XX_BLACK);
  tft.setCursor(4, 52);
  tft.setTextColor(ST77XX_GREEN);
  tft.println("Karte erkannt:");
  tft.setCursor(4, 66);
  tft.println(uid);
  tft.setTextColor(ST77XX_WHITE);

  // Auf SD protokollieren - RFID vorher sauber beenden!
  rfid.PICC_HaltA();
  rfid.PCD_StopCrypto1();

  if (sdBereit) {
    File log = SD.open("zugang.csv", FILE_WRITE);
    if (log) {
      log.print(millis());
      log.print(";");
      log.println(uid);
      log.close();
      Serial.println(F("auf SD gespeichert"));
    } else {
      Serial.println(F("Datei liess sich nicht oeffnen"));
    }
  }

  delay(1200);
}

5ESP32: zwei SPI-Busse parallel nutzen

Der ESP32 bringt zwei frei nutzbare SPI-Controller mit: VSPI (SPI3) und HSPI (SPI2). Das ist Gold wert, wenn ein langsames Gerät ein schnelles ausbremsen würde – etwa eine SD-Karte, die mit 4 MHz läuft, neben einem Display, das 40 MHz verträgt:

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

// VSPI - Standardbus, hier fuer das schnelle Display
#define VSPI_SCK   18
#define VSPI_MISO  19
#define VSPI_MOSI  23
#define CS_TFT      5

// HSPI - zweiter Bus, hier fuer die SD-Karte
#define HSPI_SCK   14
#define HSPI_MISO  12
#define HSPI_MOSI  13
#define CS_SD      15

SPIClass spiTFT(VSPI);
SPIClass spiSD(HSPI);

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

  pinMode(CS_TFT, OUTPUT); digitalWrite(CS_TFT, HIGH);
  pinMode(CS_SD,  OUTPUT); digitalWrite(CS_SD,  HIGH);

  spiTFT.begin(VSPI_SCK, VSPI_MISO, VSPI_MOSI, CS_TFT);
  spiSD.begin(HSPI_SCK, HSPI_MISO, HSPI_MOSI, CS_SD);

  // SD an den zweiten Bus haengen, bewusst langsam mit 4 MHz
  if (SD.begin(CS_SD, spiSD, 4000000)) {
    Serial.println("SD auf HSPI bereit");
    Serial.printf("Groesse: %llu MB\n", SD.cardSize() / (1024ULL * 1024ULL));
  } else {
    Serial.println("SD-Init fehlgeschlagen");
  }

  // Beispielhafte Rohtransaktion auf dem schnellen Bus
  spiTFT.beginTransaction(SPISettings(40000000, MSBFIRST, SPI_MODE0));
  digitalWrite(CS_TFT, LOW);
  spiTFT.transfer(0x00);
  digitalWrite(CS_TFT, HIGH);
  spiTFT.endTransaction();
}

void loop() {
  File f = SD.open("/messwerte.csv", FILE_APPEND);
  if (f) {
    f.printf("%lu;%.2f\n", millis(), (float)random(0, 10000) / 100.0);
    f.close();
  }
  delay(2000);
}

Taktrate richtig wählen

Schneller ist nicht automatisch besser. Auf einem Breadboard mit 20 cm Jumperkabeln wird das Signal ab etwa 10 MHz merklich unsauber – Übersprechen und Reflexionen sorgen für sporadische Bitfehler, die sich als „funktioniert meistens“ äußern. Das ist die unangenehmste Fehlerklasse überhaupt.

Wenn dein Aufbau stabil läuft und du ihn dauerhaft haben willst, ist das ein guter Moment für den Umzug auf eine Lochrasterplatine. Kurze, gelötete Leitungen vertragen deutlich höhere Taktraten – wie das geht, zeigt der Artikel Vom Breadboard zur Lochrasterplatine.

Troubleshooting