Prueba de bucle SPI: Domina el protocolo con Velxio

Introducción

El interfaz periférico serie (SPI) es un protocolo de comunicación serie síncrono ampliamente utilizado para conectar microcontroladores a sensores, pantallas y chips de memoria. En este tutorial, construiremos una prueba de bucle SPI usando el simulador Velxio. La prueba de bucle envía bytes a través de SPI y lee la respuesta, confirmando que el protocolo funciona correctamente. Como no hay un dispositivo esclavo físico, el simulador devuelve el byte enviado, lo que lo convierte en una forma perfecta de aprender SPI sin ningún hardware.

Recorrido del circuito

Empecemos configurando el circuito. El único componente que necesitamos es un Arduino Uno, que colocaremos en el lienzo.

Para añadir el Arduino Uno, abre el selector de componentes haciendo clic en el icono ”+” de la barra de herramientas del lienzo.

Busca “Arduino Uno” y colócalo en el lienzo. El Arduino Uno tiene pines SPI dedicados:

• 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 usaremos como selección de chip)

En esta prueba de bucle, no necesitamos ningún cableado externo porque las señales SPI son internas al Arduino. Sin embargo, debemos asegurarnos de que el pin SS (pin 10) esté configurado como salida y se ponga en alto inicialmente, y luego en bajo durante la comunicación. El código se encarga de esto.

Recorrido del código

Ahora examinemos el código. Abre el editor de código haciendo clic en la pestaña “Código” de la barra de herramientas del editor.

El código está escrito en Arduino C++ y utiliza la librería integrada SPI.h. No se necesitan librerías externas.

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

Desglosemos las partes clave:

• #include <SPI.h>: Incluye la librería SPI de Arduino.
• #define SS_PIN 10: Define el pin de selección de esclavo como el pin 10.
• setup(): Inicializa la comunicación serie a 9600 baudios, configura el pin SS como salida y lo pone en alto, luego llama a SPI.begin() para inicializar el periférico SPI. El divisor de reloj se establece en 16, dando una frecuencia de reloj de F_CPU / 16 (1 MHz para un Arduino de 16 MHz).
• Patrón de prueba: Se envía un array de 8 bytes (0xAA, 0x55, 0xFF, 0x00, 0x42, 0xDE, 0xAD, 0xBE) uno por uno.
• digitalWrite(SS_PIN, LOW): Selecciona el esclavo (en bucle, esto es solo un paso lógico).
• SPI.transfer(sent): Envía un byte y simultáneamente recibe un byte. En bucle, el byte recibido es igual al byte enviado.
• Salida serie: Cada transmisión se imprime en formato hexadecimal, y si los bytes enviado y recibido coinciden, se añade “(loopback OK)”.
• digitalWrite(SS_PIN, HIGH): Deselecciona el esclavo después de la transferencia.
• loop(): Vacía excepto por un retardo, ya que la prueba se ejecuta solo una vez en setup().

Conceptos clave

• Protocolo SPI: SPI es un protocolo síncrono full-duplex con cuatro cables: MOSI, MISO, SCK y SS. El maestro genera el reloj y controla la selección de esclavo.
• Bucle: Conectar MOSI a MISO (o usar un simulador que haga eco) permite probar el hardware SPI sin un esclavo externo.
• Divisor de reloj: La función SPI.setClockDivider() establece la frecuencia de SCK en relación con el reloj del sistema. Divisores más bajos significan comunicación más rápida.
• SPI.transfer(): Esta función envía y recibe un byte simultáneamente. Es el núcleo de la comunicación SPI.

Errores comunes y consejos de depuración

• Configuración del pin SS: El pin SS debe configurarse como salida; de lo contrario, el hardware SPI podría cambiar automáticamente al modo esclavo. Siempre establece pinMode(SS_PIN, OUTPUT) y ponlo en alto cuando esté inactivo.
• Desajuste de velocidad de baudios: Asegúrate de que la velocidad de baudios del Monitor Serie coincida con Serial.begin(9600). En Velxio, el monitor serie se abre automáticamente.
• Polaridad y fase del reloj: El modo SPI predeterminado (modo 0) usa SCK inactivo en bajo y los datos se muestrean en el flanco de subida. Si tu esclavo espera un modo diferente, usa SPI.setDataMode().
• Sin cableado externo: En esta prueba de bucle, no se necesitan cables. Si estuvieras conectando un esclavo real, verifica las conexiones: MOSI a MOSI, MISO a MISO, SCK a SCK y SS a SS.

Extensiones sugeridas

• Añadir un esclavo externo: Simula un sensor o pantalla añadiendo un segundo Arduino como esclavo y escribiendo un sketch de esclavo.
• Cambiar la velocidad del reloj: Experimenta con diferentes divisores de reloj (por ejemplo, SPI_CLOCK_DIV2, SPI_CLOCK_DIV128) y observa el efecto en la velocidad de transmisión.
• Enviar datos más grandes: Modifica el patrón de prueba para enviar una cadena o una lectura de sensor.
• Usar interrupciones: Implementa la comunicación SPI con interrupciones para transferencias no bloqueantes.

Pruébalo tú mismo

¿Listo para sumergirte? Abre el ejemplo en vivo en Velxio y ejecuta la simulación. Verás la salida serie mostrando cada byte transmitido y recibido, confirmando el bucle.

Abre la prueba de bucle SPI en Velxio

¡Feliz simulación!