SPI-Loopback-Test: Meistern Sie das Protokoll mit Velxio

Einführung

Serial Peripheral Interface (SPI) ist ein synchrones serielles Kommunikationsprotokoll, das häufig verwendet wird, um Mikrocontroller mit Sensoren, Displays und Speicherchips zu verbinden. In diesem Tutorial erstellen wir einen SPI-Loopback-Test mit dem Velxio-Simulator. Der Loopback-Test sendet Bytes über SPI und liest die Antwort zurück, um zu bestätigen, dass das Protokoll korrekt funktioniert. Da kein physisches Slave-Gerät vorhanden ist, gibt der Simulator das gesendete Byte zurück – eine ideale Möglichkeit, SPI ohne Hardware zu erlernen.

Schaltungsaufbau

Beginnen wir mit dem Aufbau der Schaltung. Die einzige benötigte Komponente ist ein Arduino Uno, den wir auf der Arbeitsfläche platzieren.

Um den Arduino Uno hinzuzufügen, öffnen Sie die Komponentenauswahl, indem Sie auf das „+“-Symbol in der Symbolleiste der Arbeitsfläche klicken.

Suchen Sie nach „Arduino Uno” und platzieren Sie ihn auf der Arbeitsfläche. Der Arduino Uno hat dedizierte SPI-Pins:

• MOSI (Master Out Slave In) – Pin 11
• MISO (Master In Slave Out) – Pin 12
• SCK (Serial Clock) – Pin 13
• SS (Slave Select) – Pin 10 (wir verwenden dies als Chip-Select)

Bei diesem Loopback-Test ist keine externe Verdrahtung erforderlich, da die SPI-Signale intern im Arduino verlaufen. Wir müssen jedoch sicherstellen, dass der SS-Pin (Pin 10) als Ausgang konfiguriert ist und zuerst auf HIGH, dann während der Kommunikation auf LOW gesetzt wird. Der Code übernimmt dies.

Code-Erklärung

Betrachten wir nun den Code. Öffnen Sie den Code-Editor, indem Sie auf den Reiter „Code” in der Editor-Symbolleiste klicken.

Der Code ist in Arduino C++ geschrieben und verwendet die integrierte Bibliothek SPI.h. Es werden keine externen Bibliotheken benötigt.

// SPI Loopback Test
// Sends bytes via SPI and logs the exchange.
// Without a physical slave, the emulator returns the sent byte.

#include <SPI.h>

#define SS_PIN 10

void setup() {
  Serial.begin(9600);
  Serial.println("========================");
  Serial.println("  SPI Protocol Test");
  Serial.println("========================");
  Serial.println();

  pinMode(SS_PIN, OUTPUT);
  digitalWrite(SS_PIN, HIGH);
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV16);

  Serial.println("SPI initialized.");
  Serial.print("Clock divider: 16 (");
  Serial.print(F_CPU / 16);
  Serial.println(" Hz)");
  Serial.println();

  // Send test pattern
  Serial.println("Sending test pattern via SPI:");
  byte testData[] = {0xAA, 0x55, 0xFF, 0x00, 0x42, 0xDE, 0xAD, 0xBE};

  digitalWrite(SS_PIN, LOW);  // Select slave

  for (int i = 0; i < sizeof(testData); i++) {
    byte sent = testData[i];
    byte received = SPI.transfer(sent);

    Serial.print("  TX: 0x");
    if (sent < 16) Serial.print("0");
    Serial.print(sent, HEX);
    Serial.print("  RX: 0x");
    if (received < 16) Serial.print("0");
    Serial.print(received, HEX);

    if (sent == received) {
      Serial.println("  (loopback OK)");
    } else {
      Serial.println();
    }
  }

  digitalWrite(SS_PIN, HIGH);  // Deselect slave

  Serial.println();
  Serial.println("SPI test complete.");
}

void loop() {
  delay(1000);
}

Lassen Sie uns die wichtigsten Teile aufschlüsseln:

• #include <SPI.h>: Bindet die Arduino-SPI-Bibliothek ein.
• #define SS_PIN 10: Definiert den Slave-Select-Pin als Pin 10.
• setup(): Initialisiert die serielle Kommunikation mit 9600 Baud, setzt den SS-Pin als Ausgang und auf HIGH, ruft dann SPI.begin() auf, um das SPI-Peripheriegerät zu initialisieren. Der Clock-Teiler wird auf 16 gesetzt, was eine Taktfrequenz von F_CPU / 16 (1 MHz bei einem 16-MHz-Arduino) ergibt.
• Testmuster: Ein Array von 8 Bytes (0xAA, 0x55, 0xFF, 0x00, 0x42, 0xDE, 0xAD, 0xBE) wird nacheinander gesendet.
• digitalWrite(SS_PIN, LOW): Wählt den Slave aus (im Loopback ist dies nur ein logischer Schritt).
• SPI.transfer(sent): Sendet ein Byte und empfängt gleichzeitig ein Byte. Im Loopback ist das empfangene Byte gleich dem gesendeten Byte.
• Serielle Ausgabe: Jede Übertragung wird im Hexadezimalformat ausgegeben, und wenn gesendetes und empfangenes Byte übereinstimmen, wird „(loopback OK)” angehängt.
• digitalWrite(SS_PIN, HIGH): Deaktiviert den Slave nach der Übertragung.
• loop(): Leer bis auf eine Verzögerung, da der Test nur einmal in setup() ausgeführt wird.

Wichtige Konzepte

• SPI-Protokoll: SPI ist ein synchrones, vollduplexfähiges Protokoll mit vier Leitungen: MOSI, MISO, SCK und SS. Der Master erzeugt den Takt und steuert den Slave-Select.
• Loopback: Durch Verbinden von MOSI mit MISO (oder Verwendung eines Simulators, der echoed) kann die SPI-Hardware ohne externen Slave getestet werden.
• Clock-Teiler: Die Funktion SPI.setClockDivider() stellt die SCK-Frequenz relativ zum Systemtakt ein. Niedrigere Teiler bedeuten schnellere Kommunikation.
• SPI.transfer(): Diese Funktion sendet und empfängt gleichzeitig ein Byte. Sie ist der Kern der SPI-Kommunikation.

Häufige Fallstricke und Debugging-Tipps

• SS-Pin-Konfiguration: Der SS-Pin muss als Ausgang konfiguriert sein; andernfalls kann die SPI-Hardware automatisch in den Slave-Modus wechseln. Setzen Sie immer pinMode(SS_PIN, OUTPUT) und setzen Sie ihn im Leerlauf auf HIGH.
• Baudraten-Konflikt: Stellen Sie sicher, dass die Baudrate des seriellen Monitors mit Serial.begin(9600) übereinstimmt. In Velxio öffnet sich der serielle Monitor automatisch.
• Taktpolarität und -phase: Der Standard-SPI-Modus (Modus 0) verwendet SCK im Leerlauf auf LOW und Datenabtastung bei steigender Flanke. Wenn Ihr Slave einen anderen Modus erwartet, verwenden Sie SPI.setDataMode().
• Keine externe Verdrahtung: Bei diesem Loopback-Test werden keine Kabel benötigt. Wenn Sie einen tatsächlichen Slave anschließen, überprüfen Sie die Verbindungen: MOSI an MOSI, MISO an MISO, SCK an SCK und SS an SS.

Vorschläge für Erweiterungen

• Externen Slave hinzufügen: Simulieren Sie einen Sensor oder ein Display, indem Sie einen zweiten Arduino als Slave hinzufügen und einen Slave-Sketch schreiben.
• Taktrate ändern: Experimentieren Sie mit verschiedenen Clock-Teilern (z. B. SPI_CLOCK_DIV2, SPI_CLOCK_DIV128) und beobachten Sie die Auswirkung auf die Übertragungsgeschwindigkeit.
• Größere Daten senden: Ändern Sie das Testmuster, um einen String oder einen Sensorwert zu senden.
• Interrupts verwenden: Implementieren Sie die SPI-Kommunikation mit Interrupts für nicht-blockierende Übertragungen.

Probieren Sie es selbst aus

Bereit loszulegen? Öffnen Sie das Live-Beispiel in Velxio und führen Sie die Simulation aus. Sie sehen die serielle Ausgabe mit jedem gesendeten und empfangenen Byte, was den Loopback bestätigt.

Öffnen Sie den SPI-Loopback-Test in Velxio

Viel Spaß beim Simulieren!