Test di Loopback SPI: Padroneggia il Protocollo con Velxio

Introduzione

Il Serial Peripheral Interface (SPI) è un protocollo di comunicazione seriale sincrono ampiamente utilizzato per collegare microcontrollori a sensori, display e chip di memoria. In questo tutorial, realizzeremo un test di loopback SPI utilizzando il simulatore Velxio. Il test di loopback invia byte tramite SPI e legge la risposta, confermando che il protocollo funzioni correttamente. Poiché non è presente un dispositivo slave fisico, il simulatore restituisce il byte inviato, rendendolo un modo perfetto per imparare lo SPI senza alcun hardware.

Panoramica del Circuito

Iniziamo impostando il circuito. L’unico componente di cui abbiamo bisogno è un Arduino Uno, che posizioneremo sulla tela.

Per aggiungere l’Arduino Uno, apri il selettore componenti cliccando sull’icona ”+” nella barra degli strumenti della tela.

Cerca “Arduino Uno” e posizionalo sulla tela. L’Arduino Uno ha pin SPI dedicati:

• MOSI (Master Out Slave In) – pin 11
• MISO (Master In Slave Out) – pin 12
• SCK (Serial Clock) – pin 13
• SS (Slave Select) – pin 10 (lo useremo come chip select)

In questo test di loopback, non è necessario alcun cablaggio esterno poiché i segnali SPI sono interni all’Arduino. Tuttavia, dobbiamo assicurarci che il pin SS (pin 10) sia configurato come output e portato a livello alto inizialmente, poi basso durante la comunicazione. Il codice gestisce questo aspetto.

Analisi del Codice

Ora esaminiamo il codice. Apri l’editor del codice cliccando sulla scheda “Code” nella barra degli strumenti dell’editor.

Il codice è scritto in Arduino C++ e utilizza la libreria integrata SPI.h. Non sono necessarie librerie esterne.

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

Analizziamo le parti chiave:

• #include <SPI.h>: Include la libreria SPI di Arduino.
• #define SS_PIN 10: Definisce il pin slave select come pin 10.
• setup(): Inizializza la comunicazione seriale a 9600 baud, imposta il pin SS come output e lo porta a livello alto, quindi chiama SPI.begin() per inizializzare la periferica SPI. Il divisore di clock è impostato a 16, fornendo una frequenza di clock di F_CPU / 16 (1 MHz per un Arduino a 16 MHz).
• Pattern di test: Un array di 8 byte (0xAA, 0x55, 0xFF, 0x00, 0x42, 0xDE, 0xAD, 0xBE) viene inviato uno alla volta.
• digitalWrite(SS_PIN, LOW): Seleziona lo slave (nel loopback, questo è solo un passaggio logico).
• SPI.transfer(sent): Invia un byte e contemporaneamente ne riceve uno. In loopback, il byte ricevuto è uguale al byte inviato.
• Uscita seriale: Ogni trasmissione viene stampata in formato esadecimale e, se i byte inviati e ricevuti corrispondono, viene aggiunto “(loopback OK)”.
• digitalWrite(SS_PIN, HIGH): Deseleziona lo slave dopo il trasferimento.
• loop(): Vuota tranne che per un ritardo, poiché il test viene eseguito una sola volta in setup().

Concetti Chiave

• Protocollo SPI: Lo SPI è un protocollo sincrono full-duplex con quattro fili: MOSI, MISO, SCK e SS. Il master genera il clock e controlla lo slave select.
• Loopback: Collegare MOSI a MISO (o utilizzare un simulatore che risponde) consente di testare l’hardware SPI senza uno slave esterno.
• Divisore di Clock: La funzione SPI.setClockDivider() imposta la frequenza SCK rispetto al clock di sistema. Divisori più bassi significano comunicazione più veloce.
• SPI.transfer(): Questa funzione invia e riceve simultaneamente un byte. È il cuore della comunicazione SPI.

Insidie Comuni e Suggerimenti per il Debug

• Configurazione del Pin SS: Il pin SS deve essere configurato come output; altrimenti, l’hardware SPI potrebbe passare automaticamente alla modalità slave. Imposta sempre pinMode(SS_PIN, OUTPUT) e portalo a livello alto quando è inattivo.
• Disallineamento del Baud Rate: Assicurati che il baud rate del Monitor Seriale corrisponda a Serial.begin(9600). In Velxio, il monitor seriale si apre automaticamente.
• Polarità e Fase del Clock: La modalità SPI predefinita (modalità 0) utilizza SCK inattivo basso e dati campionati sul fronte di salita. Se il tuo slave richiede una modalità diversa, usa SPI.setDataMode().
• Nessun Cablaggio Esterno: In questo test di loopback, non sono necessari fili. Se stessi collegando uno slave reale, ricontrolla le connessioni: MOSI a MOSI, MISO a MISO, SCK a SCK e SS a SS.

Estensioni Suggerite

• Aggiungi uno Slave Esterno: Simula un sensore o un display aggiungendo un secondo Arduino come slave e scrivendo uno sketch per lo slave.
• Cambia la Velocità del Clock: Sperimenta con diversi divisori di clock (ad esempio, SPI_CLOCK_DIV2, SPI_CLOCK_DIV128) e osserva l’effetto sulla velocità di trasmissione.
• Invia Dati Più Grandi: Modifica il pattern di test per inviare una stringa o una lettura del sensore.
• Usa gli Interrupt: Implementa la comunicazione SPI con interrupt per trasferimenti non bloccanti.

Provalo Tu Stesso

Pronto per iniziare? Apri l’esempio live in Velxio ed esegui la simulazione. Vedrai l’output seriale che mostra ogni byte trasmesso e ricevuto, confermando il loopback.

Apri il Test di Loopback SPI in Velxio

Buona simulazione!