Pico SPI Loopback : testez la communication série de votre RP2040

Introduction

Le SPI (Serial Peripheral Interface) est un protocole de communication série synchrone largement utilisé pour connecter des microcontrôleurs à des capteurs, des écrans et d’autres périphériques. Dans ce tutoriel, nous allons construire un simple test de boucle de retour SPI sur le Raspberry Pi Pico en utilisant le simulateur en ligne Velxio. Le Pico enverra des octets via SPI0 et les lira en retour, tandis que trois LED indiqueront visuellement l’activité sur les lignes MOSI, MISO et SCK. C’est un excellent moyen de vérifier que votre matériel SPI et votre câblage fonctionnent correctement avant de passer à des projets plus complexes.

Schéma du circuit pico-spi-loopback sur le canevas du simulateur Velxio

Présentation du circuit

Examinons les composants et le câblage de ce circuit.

Composants

Raspberry Pi Pico (le cerveau de l’opération)
LED rouge – connectée à la ligne MOSI (GP7)
LED verte – connectée à la ligne MISO (GP4)
LED jaune – connectée à la ligne SCK (GP6)

Câblage

Les broches SPI0 du Pico sont mappées comme suit :

MOSI (Master Out Slave In) – GP7 (D7 sur le brochage Nano RP2040 Connect)
MISO (Master In Slave Out) – GP4 (D4)
SCK (Serial Clock) – GP6 (D6)
CS (Chip Select) – non utilisé dans ce test de boucle de retour

L’anode (A) de chaque LED se connecte à la broche SPI correspondante, et sa cathode (C) se connecte à GND (GND.1 sur le Pico). Les couleurs des fils dans le simulateur sont :

MOSI : fil rouge (#ff4444)
MISO : fil vert (#00cc00)
SCK : fil jaune (#ffaa00)
Masse : fil noir (#000000)

Cette configuration simple vous permet de visualiser l’activité SPI : les LED clignoteront lors de la transmission des données.

Explication du code

Voici le sketch Arduino complet pour le 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);
}

Comment ça fonctionne

Configuration série : Nous démarrons la communication série à 115200 bauds pour afficher les résultats dans le moniteur série.
Initialisation SPI : SPI.begin() initialise le périphérique SPI0. SPI.beginTransaction() configure le bus avec une vitesse d’horloge de 1 MHz, un ordre des données MSB en premier, et le mode SPI 0 (CPOL=0, CPHA=0).
Données de test : Nous définissons un tableau de cinq octets de test : 0x55, 0xAA, 0xFF, 0x00 et 0x42. Ceux-ci couvrent des bits alternés, tous à 1, tous à 0, et un motif mixte.
Transfert en boucle : Pour chaque octet, nous appelons SPI.transfer(). Cela envoie simultanément un octet et reçoit l’octet présent sur la ligne MISO. Comme nous avons une boucle de retour (MISO connectée à MOSI, en externe ou en interne), l’octet reçu devrait correspondre à l’octet envoyé.
Affichage des résultats : Le sketch affiche les octets transmis (TX) et reçus (RX) en hexadécimal, ainsi qu’un statut “MATCH” ou “DIFFER”.
Nettoyage : SPI.endTransaction() libère le bus SPI.

Concepts clés

Protocole SPI : Le SPI est un protocole synchrone full-duplex avec un maître (le Pico) et un ou plusieurs esclaves. Il utilise quatre fils : MOSI, MISO, SCK et CS (chip select). Dans ce test de boucle de retour, nous n’utilisons que MOSI, MISO et SCK.
Boucle de retour : Connecter MOSI à MISO permet au maître de recevoir ses propres données transmises. C’est un test courant pour vérifier que le matériel SPI et le câblage sont fonctionnels.
Modes SPI : Le mode (0, 1, 2 ou 3) définit la polarité et la phase de l’horloge. Le mode 0 (CPOL=0, CPHA=0) est le plus courant.
Débit en bauds : Le débit en bauds du moniteur série (115200) doit correspondre au réglage Serial.begin() du sketch.

Pièges courants et conseils de débogage

Mauvais mappage des broches : Les commentaires du code mentionnent les broches SPI0 par défaut (GP16, GP19, GP18), mais le câblage réel utilise GP7, GP4 et GP6. Vérifiez toujours le brochage de votre carte spécifique. Dans Velxio, les broches SPI0 du Pico sont GP7 (MOSI), GP4 (MISO) et GP6 (SCK).
Masse manquante : Assurez-vous que toutes les LED ont leurs cathodes connectées à GND. Sans chemin de masse, les LED ne s’allumeront pas.
Le moniteur série n’affiche rien : Vérifiez que le débit en bauds est réglé sur 115200 dans le moniteur série de Velxio. Vous pouvez l’ouvrir depuis la barre d’outils de l’éditeur.
Les LED ne clignotent pas : Vérifiez que les LED sont câblées sur les bonnes broches et que le code s’exécute. Les LED clignoteront rapidement pendant la boucle for, puis resteront éteintes.
La boucle de retour ne fonctionne pas : Si les octets reçus ne correspondent pas, vérifiez que MOSI et MISO sont connectés. Dans ce circuit, ils ne sont pas directement connectés ; les LED sont simplement des indicateurs. Pour une véritable boucle de retour, vous devrez connecter GP7 à GP4 avec un fil. Cependant, le code s’exécute et affiche les résultats — l’octet reçu sera celui présent sur la ligne MISO (probablement 0xFF ou 0x00 si elle est en l’air).

Extensions suggérées

Ajouter une boucle de retour physique : Connectez un fil de GP7 (MOSI) à GP4 (MISO) pour réellement boucler les données. Les octets reçus devraient alors correspondre parfaitement.
Utiliser un mode SPI différent : Remplacez SPI_MODE0 par SPI_MODE1, SPI_MODE2 ou SPI_MODE3 et observez l’effet sur les LED.
Augmenter la vitesse d’horloge : Essayez 8 MHz ou 16 MHz et voyez si les LED clignotent encore visiblement.
Ajouter plus de LED : Connectez des LED à la broche CS (GP17) et à d’autres GPIO pour visualiser des signaux supplémentaires.
Interfacer avec un véritable périphérique SPI : Remplacez la boucle de retour par un capteur SPI (par exemple, un capteur de température) et lisez ses données.

Essayez par vous-même

Prêt à construire ce projet ? Ouvrez l’exemple en direct dans Velxio et commencez à expérimenter :

Ouvrir Pico SPI Loopback dans Velxio

Utilisez la barre d’outils de l’éditeur Velxio pour compiler et exécuter le code, et ouvrez le moniteur série pour voir les résultats. La barre d’outils du canevas vous permet de zoomer et de faire un panoramique sur le circuit. Si vous devez ajouter des composants, utilisez le sélecteur de composants.

Barre d'outils de l'éditeur Velxio avec les commandes de compilation et d'exécution