Loopback SPI no Pico: Teste a Comunicação Serial do seu RP2040

Introdução

SPI (Interface Serial Periférica) é um protocolo de comunicação serial síncrona amplamente usado para conectar microcontroladores a sensores, displays e outros periféricos. Neste tutorial, vamos construir um teste simples de loopback SPI no Raspberry Pi Pico usando o simulador no navegador da Velxio. O Pico enviará bytes via SPI0 e os lerá de volta, enquanto três LEDs indicam visualmente a atividade nas linhas MOSI, MISO e SCK. Esta é uma ótima maneira de verificar se o hardware SPI e a fiação estão funcionando corretamente antes de avançar para projetos mais complexos.

Explicação do Circuito

Vamos analisar os componentes e a fiação deste circuito.

Componentes

• Raspberry Pi Pico (o cérebro da operação)
• LED Vermelho – conectado à linha MOSI (GP7)
• LED Verde – conectado à linha MISO (GP4)
• LED Amarelo – conectado à linha SCK (GP6)

Fiação

Os pinos SPI0 do Pico são mapeados da seguinte forma:

• MOSI (Master Out Slave In) – GP7 (D7 no pinout do Nano RP2040 Connect)
• MISO (Master In Slave Out) – GP4 (D4)
• SCK (Serial Clock) – GP6 (D6)
• CS (Chip Select) – não utilizado neste teste de loopback

O ânodo (A) de cada LED se conecta ao respectivo pino SPI, e seu cátodo (C) se conecta ao GND (GND.1 no Pico). As cores dos fios no simulador são:

• MOSI: fio vermelho (#ff4444)
• MISO: fio verde (#00cc00)
• SCK: fio amarelo (#ffaa00)
• Terra: fio preto (#000000)

Esta configuração simples permite visualizar a atividade SPI: os LEDs piscarão conforme os dados são transmitidos.

Explicação do Código

Aqui está o sketch Arduino completo para o Pico:

// Raspberry Pi Pico — Teste de Loopback SPI
// Envia bytes via SPI0 e lê a resposta do loopback
// Pinos SPI0 padrão: MISO=GP16, MOSI=GP19, SCK=GP18, CS=GP17

#include <SPI.h>

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

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

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

  Serial.println("Enviando bytes e lendo 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] ? "IGUAL" : "DIFERENTE");
  }

  SPI.endTransaction();
  Serial.println();
  Serial.println("Teste SPI concluído.");
}

void loop() {
  delay(10000);
}

Como Funciona

1. Configuração Serial: Iniciamos a comunicação serial a 115200 baud para imprimir os resultados no Monitor Serial.
2. Inicialização SPI: SPI.begin() inicializa o periférico SPI0. SPI.beginTransaction() configura o barramento com velocidade de clock de 1 MHz, ordem de dados MSB primeiro e modo SPI 0 (CPOL=0, CPHA=0).
3. Dados de Teste: Definimos um array de cinco bytes de teste: 0x55, 0xAA, 0xFF, 0x00 e 0x42. Eles cobrem bits alternados, todos 1, todos 0 e um padrão misto.
4. Transferência em Loopback: Para cada byte, chamamos SPI.transfer(). Isso envia um byte e simultaneamente recebe o byte presente na linha MISO. Como temos um loopback (MISO conectado ao MOSI externa ou internamente), o byte recebido deve corresponder ao byte enviado.
5. Exibição dos Resultados: O sketch imprime os bytes transmitidos (TX) e recebidos (RX) em hexadecimal, junto com um status “IGUAL” ou “DIFERENTE”.
6. Limpeza: SPI.endTransaction() libera o barramento SPI.

Conceitos Principais

• Protocolo SPI: SPI é um protocolo síncrono full-duplex com um mestre (o Pico) e um ou mais escravos. Ele usa quatro fios: MOSI, MISO, SCK e CS (chip select). Neste teste de loopback, usamos apenas MOSI, MISO e SCK.
• Loopback: Conectar MOSI a MISO permite que o mestre receba seus próprios dados transmitidos. Este é um teste comum para verificar se o hardware SPI e a fiação estão funcionais.
• Modos SPI: O modo (0, 1, 2 ou 3) define a polaridade e a fase do clock. O modo 0 (CPOL=0, CPHA=0) é o mais comum.
• Taxa de Transmissão: A taxa de transmissão do monitor serial (115200) deve corresponder à configuração de Serial.begin() no sketch.

Problemas Comuns e Dicas de Depuração

• Mapeamento de Pinos Incorreto: Os comentários do código mencionam os pinos SPI0 padrão (GP16, GP19, GP18), mas a fiação real usa GP7, GP4 e GP6. Sempre verifique o pinout da sua placa específica. No Velxio, os pinos SPI0 do Pico são GP7 (MOSI), GP4 (MISO) e GP6 (SCK).
• Falta de Conexão ao Terra: Certifique-se de que todos os LEDs tenham seus cátodos conectados ao GND. Sem um caminho para o terra, os LEDs não acenderão.
• Monitor Serial Sem Exibição: Verifique se a taxa de transmissão está configurada para 115200 no Monitor Serial do Velxio. Você pode abri-lo na barra de ferramentas do editor.
• LEDs Não Piscam: Verifique se os LEDs estão conectados aos pinos corretos e se o código está em execução. Os LEDs piscarão rapidamente durante o loop for e depois permanecerão apagados.
• Loopback Não Funciona: Se os bytes recebidos não corresponderem, verifique se MOSI e MISO estão conectados. Neste circuito, eles não estão diretamente conectados; os LEDs são apenas indicadores. Para um loopback real, você precisaria conectar GP7 a GP4 com um fio. No entanto, o código ainda executa e imprime resultados — o byte recebido será o que estiver na linha MISO (provavelmente 0xFF ou 0x00 se estiver flutuando).

Extensões Sugeridas

• Adicione um Loopback Físico: Conecte um fio de GP7 (MOSI) a GP4 (MISO) para realmente fazer o loopback dos dados. Assim, os bytes recebidos devem corresponder perfeitamente.
• Use um Modo SPI Diferente: Altere SPI_MODE0 para SPI_MODE1, SPI_MODE2 ou SPI_MODE3 e observe o efeito nos LEDs.
• Aumente a Velocidade do Clock: Tente 8 MHz ou 16 MHz e veja se os LEDs ainda piscam visivelmente.
• Adicione Mais LEDs: Conecte LEDs ao pino CS (GP17) e a outros GPIOs para visualizar sinais adicionais.
• Interaja com um Dispositivo SPI Real: Substitua o loopback por um sensor SPI (por exemplo, sensor de temperatura) e leia seus dados.

Experimente Você Mesmo

Pronto para construir este projeto? Abra o exemplo ao vivo no Velxio e comece a experimentar:

Abrir Loopback SPI no Pico no Velxio

Use a barra de ferramentas do editor Velxio para compilar e executar o código, e abra o Monitor Serial para ver os resultados. A barra de ferramentas do canvas permite ampliar e mover o circuito. Se precisar adicionar componentes, use o seletor de componentes.

Boa construção!