Pico SPI Loopback: Testen Sie die serielle Kommunikation Ihres RP2040

Einführung

SPI (Serial Peripheral Interface) ist ein synchrones serielles Kommunikationsprotokoll, das häufig verwendet wird, um Mikrocontroller mit Sensoren, Displays und anderen Peripheriegeräten zu verbinden. In diesem Tutorial bauen wir einen einfachen SPI-Loopback-Test auf dem Raspberry Pi Pico mit dem Velxio In-Browser-Simulator. Der Pico sendet Bytes über SPI0 und liest sie zurück, während drei LEDs die Aktivität auf den MOSI-, MISO- und SCK-Leitungen anzeigen. Dies ist eine großartige Möglichkeit, um zu überprüfen, ob Ihre SPI-Hardware und Verkabelung korrekt funktionieren, bevor Sie zu komplexeren Projekten übergehen.

Schaltplan des Pico-SPI-Loopbacks auf der Velxio-Simulator-Leinwand

Schaltungsaufbau

Schauen wir uns die Komponenten und die Verkabelung in dieser Schaltung an.

Komponenten

Raspberry Pi Pico (das Gehirn der Operation)
Rote LED – angeschlossen an die MOSI-Leitung (GP7)
Grüne LED – angeschlossen an die MISO-Leitung (GP4)
Gelbe LED – angeschlossen an die SCK-Leitung (GP6)

Verkabelung

Die SPI0-Pins des Pico sind wie folgt zugeordnet:

MOSI (Master Out Slave In) – GP7 (D7 im Nano RP2040 Connect Pinout)
MISO (Master In Slave Out) – GP4 (D4)
SCK (Serial Clock) – GP6 (D6)
CS (Chip Select) – wird in diesem Loopback-Test nicht verwendet

Die Anode (A) jeder LED wird mit dem jeweiligen SPI-Pin verbunden, und ihre Kathode (C) wird mit GND (GND.1 auf dem Pico) verbunden. Die Drahtfarben im Simulator sind:

MOSI: roter Draht (#ff4444)
MISO: grüner Draht (#00cc00)
SCK: gelber Draht (#ffaa00)
Masse: schwarzer Draht (#000000)

Dieser einfache Aufbau ermöglicht es Ihnen, die SPI-Aktivität zu sehen: Die LEDs blinken, während Daten übertragen werden.

Code-Erklärung

Hier ist der vollständige Arduino-Sketch für den Pico:

// Raspberry Pi Pico — SPI Loopback Test
// Sends bytes over SPI0 and reads the loopback response
// Default SPI0 pins: MISO=GP16, MOSI=GP19, SCK=GP18, CS=GP17

#include <SPI.h>

void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("=== Pico SPI Loopback Test ===");
  Serial.println("SPI0: MISO=GP16, MOSI=GP19, SCK=GP18");
  Serial.println();

  SPI.begin();
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0));

  // Send test bytes
  byte testBytes[] = {0x55, 0xAA, 0xFF, 0x00, 0x42};
  int count = sizeof(testBytes);

  Serial.println("Sending bytes and reading loopback:");
  for (int i = 0; i < count; i++) {
    byte rxByte = SPI.transfer(testBytes[i]);
    Serial.print("  TX: 0x");
    if (testBytes[i] < 16) Serial.print('0');
    Serial.print(testBytes[i], HEX);
    Serial.print("  RX: 0x");
    if (rxByte < 16) Serial.print('0');
    Serial.print(rxByte, HEX);
    Serial.print("  ");
    Serial.println(rxByte == testBytes[i] ? "MATCH" : "DIFFER");
  }

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

void loop() {
  delay(10000);
}

Wie es funktioniert

Serielle Einrichtung: Wir starten die serielle Kommunikation mit 115200 Baud, um die Ergebnisse im seriellen Monitor auszugeben.
SPI-Initialisierung: SPI.begin() initialisiert das SPI0-Peripheriegerät. SPI.beginTransaction() konfiguriert den Bus mit einer Taktfrequenz von 1 MHz, MSB-first Datenreihenfolge und SPI-Modus 0 (CPOL=0, CPHA=0).
Testdaten: Wir definieren ein Array von fünf Testbytes: 0x55, 0xAA, 0xFF, 0x00 und 0x42. Diese decken alternierende Bits, alle Einsen, alle Nullen und ein gemischtes Muster ab.
Loopback-Übertragung: Für jedes Byte rufen wir SPI.transfer() auf. Dies sendet gleichzeitig ein Byte und empfängt das Byte, das sich gerade auf der MISO-Leitung befindet. Da wir einen Loopback haben (MISO extern oder intern mit MOSI verbunden), sollte das empfangene Byte mit dem gesendeten Byte übereinstimmen.
Ergebnisanzeige: Der Sketch gibt die gesendeten (TX) und empfangenen (RX) Bytes in hexadezimaler Form aus, zusammen mit einem “MATCH”- oder “DIFFER”-Status.
Bereinigung: SPI.endTransaction() gibt den SPI-Bus frei.

Wichtige Konzepte

SPI-Protokoll: SPI ist ein vollduplexes, synchrones Protokoll mit einem Master (dem Pico) und einem oder mehreren Slaves. Es verwendet vier Leitungen: MOSI, MISO, SCK und CS (Chip Select). In diesem Loopback-Test verwenden wir nur MOSI, MISO und SCK.
Loopback: Die Verbindung von MOSI mit MISO ermöglicht es dem Master, seine eigenen gesendeten Daten zu empfangen. Dies ist ein üblicher Test, um zu überprüfen, ob die SPI-Hardware und die Verkabelung funktionieren.
SPI-Modi: Der Modus (0, 1, 2 oder 3) definiert die Taktpolarität und -phase. Modus 0 (CPOL=0, CPHA=0) ist der gebräuchlichste.
Baudrate: Die Baudrate des seriellen Monitors (115200) muss mit der Einstellung Serial.begin() im Sketch übereinstimmen.

Häufige Fallstricke und Debugging-Tipps

Falsche Pin-Zuordnung: Die Code-Kommentare erwähnen die standardmäßigen SPI0-Pins (GP16, GP19, GP18), aber die tatsächliche Verkabelung verwendet GP7, GP4 und GP6. Überprüfen Sie immer das Pinout für Ihr spezifisches Board. In Velxio sind die SPI0-Pins des Pico GP7 (MOSI), GP4 (MISO) und GP6 (SCK).
Fehlende Masse: Stellen Sie sicher, dass alle LEDs mit ihren Kathoden an GND angeschlossen sind. Ohne einen Massepfad leuchten die LEDs nicht.
Serieller Monitor zeigt keine Ausgabe: Stellen Sie sicher, dass die Baudrate im Velxio-Seriellen-Monitor auf 115200 eingestellt ist. Sie können ihn über die Editor-Symbolleiste öffnen.
LEDs blinken nicht: Überprüfen Sie, ob die LEDs an die richtigen Pins angeschlossen sind und der Code ausgeführt wird. Die LEDs blinken während der for-Schleife schnell und bleiben dann aus.
Loopback funktioniert nicht: Wenn die empfangenen Bytes nicht übereinstimmen, überprüfen Sie, ob MOSI und MISO verbunden sind. In dieser Schaltung sind sie nicht direkt verbunden; die LEDs sind nur Indikatoren. Für einen echten Loopback müssten Sie GP7 mit GP4 durch einen Draht verbinden. Der Code läuft jedoch trotzdem und gibt Ergebnisse aus – das empfangene Byte ist das, was auf der MISO-Leitung anliegt (wahrscheinlich 0xFF oder 0x00, wenn sie offen ist).

Vorschläge für Erweiterungen

Physischen Loopback hinzufügen: Verbinden Sie einen Draht von GP7 (MOSI) mit GP4 (MISO), um die Daten tatsächlich zurückzuschleifen. Dann sollten die empfangenen Bytes perfekt übereinstimmen.
Einen anderen SPI-Modus verwenden: Ändern Sie SPI_MODE0 in SPI_MODE1, SPI_MODE2 oder SPI_MODE3 und beobachten Sie die Auswirkung auf die LEDs.
Taktrate erhöhen: Versuchen Sie 8 MHz oder 16 MHz und sehen Sie, ob die LEDs noch sichtbar blinken.
Weitere LEDs hinzufügen: Schließen Sie LEDs an den CS-Pin (GP17) und andere GPIOs an, um zusätzliche Signale sichtbar zu machen.
Mit einem echten SPI-Gerät verbinden: Ersetzen Sie den Loopback durch einen SPI-Sensor (z. B. Temperatursensor) und lesen Sie dessen Daten aus.

Probieren Sie es selbst aus

Bereit, dieses Projekt zu bauen? Öffnen Sie das Live-Beispiel in Velxio und beginnen Sie zu experimentieren:

Pico SPI Loopback in Velxio öffnen

Verwenden Sie die Velxio-Editor-Symbolleiste, um den Code zu kompilieren und auszuführen, und öffnen Sie den seriellen Monitor, um die Ergebnisse zu sehen. Die Leinwand-Symbolleiste ermöglicht es Ihnen, die Schaltung zu zoomen und zu verschieben. Wenn Sie Komponenten hinzufügen müssen, verwenden Sie die Komponentenauswahl.

Velxio Editor-Symbolleiste mit Kompilieren- und Ausführen-Steuerelementen