Test de boucle SPI : Maîtrisez le protocole avec Velxio

Introduction

L’interface périphérique série (SPI) est un protocole de communication série synchrone largement utilisé pour connecter des microcontrôleurs à des capteurs, des écrans et des puces mémoire. Dans ce tutoriel, nous allons construire un test de boucle SPI en utilisant le simulateur Velxio. Le test de boucle envoie des octets via SPI et lit la réponse, confirmant ainsi le bon fonctionnement du protocole. Comme il n’y a pas de périphérique esclave physique, le simulateur renvoie l’octet envoyé, ce qui en fait un moyen idéal pour apprendre le SPI sans aucun matériel.

Présentation du circuit

Commençons par configurer le circuit. Le seul composant dont nous avons besoin est un Arduino Uno, que nous placerons sur le canevas.

Pour ajouter l’Arduino Uno, ouvrez le sélecteur de composants en cliquant sur l’icône ”+” dans la barre d’outils du canevas.

Recherchez “Arduino Uno” et placez-le sur le canevas. L’Arduino Uno possède des broches SPI dédiées :

• MOSI (Master Out Slave In) – broche 11
• MISO (Master In Slave Out) – broche 12
• SCK (Serial Clock) – broche 13
• SS (Slave Select) – broche 10 (nous l’utiliserons comme sélection de puce)

Dans ce test de boucle, nous n’avons besoin d’aucun câblage externe car les signaux SPI sont internes à l’Arduino. Cependant, nous devons nous assurer que la broche SS (broche 10) est configurée comme sortie et maintenue à l’état haut initialement, puis à l’état bas pendant la communication. Le code s’en charge.

Présentation du code

Examinons maintenant le code. Ouvrez l’éditeur de code en cliquant sur l’onglet “Code” dans la barre d’outils de l’éditeur.

Le code est écrit en Arduino C++ et utilise la bibliothèque intégrée SPI.h. Aucune bibliothèque externe n’est nécessaire.

// 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);
}

Détaillons les parties clés :

• #include <SPI.h> : Inclut la bibliothèque SPI Arduino.
• #define SS_PIN 10 : Définit la broche de sélection esclave comme la broche 10.
• setup() : Initialise la communication série à 9600 bauds, configure la broche SS comme sortie et la maintient à l’état haut, puis appelle SPI.begin() pour initialiser le périphérique SPI. Le diviseur d’horloge est réglé sur 16, ce qui donne une fréquence d’horloge de F_CPU / 16 (1 MHz pour un Arduino à 16 MHz).
• Motif de test : Un tableau de 8 octets (0xAA, 0x55, 0xFF, 0x00, 0x42, 0xDE, 0xAD, 0xBE) est envoyé un par un.
• digitalWrite(SS_PIN, LOW) : Sélectionne l’esclave (en boucle, ce n’est qu’une étape logique).
• SPI.transfer(sent) : Envoie un octet et en reçoit simultanément un autre. En boucle, l’octet reçu est égal à l’octet envoyé.
• Sortie série : Chaque transmission est imprimée au format hexadécimal, et si les octets envoyés et reçus correspondent, “(loopback OK)” est ajouté.
• digitalWrite(SS_PIN, HIGH) : Désélectionne l’esclave après le transfert.
• loop() : Vide à l’exception d’une temporisation, car le test ne s’exécute qu’une seule fois dans setup().

Concepts clés

• Protocole SPI : SPI est un protocole synchrone et full-duplex avec quatre fils : MOSI, MISO, SCK et SS. Le maître génère l’horloge et contrôle la sélection de l’esclave.
• Boucle : Connecter MOSI à MISO (ou utiliser un simulateur qui fait écho) permet de tester le matériel SPI sans esclave externe.
• Diviseur d’horloge : La fonction SPI.setClockDivider() définit la fréquence SCK par rapport à l’horloge système. Des diviseurs plus faibles signifient une communication plus rapide.
• SPI.transfer() : Cette fonction envoie et reçoit simultanément un octet. C’est le cœur de la communication SPI.

Pièges courants et conseils de débogage

• Configuration de la broche SS : La broche SS doit être configurée comme sortie ; sinon, le matériel SPI peut passer automatiquement en mode esclave. Définissez toujours pinMode(SS_PIN, OUTPUT) et maintenez-la à l’état haut lorsqu’elle est inactive.
• Décalage de débit en bauds : Assurez-vous que le débit en bauds du moniteur série correspond à Serial.begin(9600). Dans Velxio, le moniteur série s’ouvre automatiquement.
• Polarité et phase de l’horloge : Le mode SPI par défaut (mode 0) utilise SCK inactif à l’état bas et les données échantillonnées sur le front montant. Si votre esclave attend un mode différent, utilisez SPI.setDataMode().
• Absence de câblage externe : Dans ce test de boucle, aucun fil n’est nécessaire. Si vous connectez un esclave réel, vérifiez les connexions : MOSI à MOSI, MISO à MISO, SCK à SCK, et SS à SS.

Extensions suggérées

• Ajouter un esclave externe : Simulez un capteur ou un écran en ajoutant un deuxième Arduino comme esclave et en écrivant un sketch esclave.
• Modifier la vitesse d’horloge : Expérimentez avec différents diviseurs d’horloge (par exemple, SPI_CLOCK_DIV2, SPI_CLOCK_DIV128) et observez l’effet sur la vitesse de transmission.
• Envoyer des données plus volumineuses : Modifiez le motif de test pour envoyer une chaîne de caractères ou une lecture de capteur.
• Utiliser des interruptions : Implémentez la communication SPI avec des interruptions pour des transferts non bloquants.

Essayez par vous-même

Prêt à vous lancer ? Ouvrez l’exemple en direct dans Velxio et exécutez la simulation. Vous verrez la sortie série affichant chaque octet transmis et reçu, confirmant la boucle.

Ouvrir le test de boucle SPI dans Velxio

Bonne simulation !