Como usar spi (interface periférica serial) no arduino para comunicação entre duas placas arduino

Um microcontrolador usa muitos protocolos diferentes para se comunicar com vários sensores e módulos. Existem muitos tipos diferentes de protocolos de comunicação para comunicação sem fio e com fio, e a técnica de comunicação mais comumente usada é a comunicação serial. A comunicação serial é o processo de enviar dados um bit por vez, sequencialmente, por um canal de comunicação ou barramento. Existem muitos tipos de comunicação serial, como comunicação UART, CAN, USB, I2C e SPI.

Neste tutorial, aprendemos sobre o protocolo SPI e como usá-lo no Arduino. Usaremos o protocolo SPI para comunicação entre dois Arduinos. Aqui, um Arduino atuará como mestre e outro como escravo, dois LEDs e botões de pressão serão conectados a ambos o Arduino. Para demonstrar a comunicação SPI, controlaremos o LED do lado mestre pelo botão no lado escravo e vice-versa usando o protocolo de comunicação SPI Serial.

O que é SPI?

SPI (Serial Peripheral Interface) é um protocolo de comunicação serial. A interface SPI foi descoberta pela Motorola em 1970. A SPI tem uma conexão full-duplex, o que significa que os dados são enviados e recebidos simultaneamente. Ou seja, um mestre pode enviar dados para um escravo e um escravo pode enviar dados para o mestre simultaneamente. SPI é uma comunicação serial síncrona que significa que o relógio é necessário para fins de comunicação.

A comunicação SPI é explicada anteriormente em outros microcontroladores:

Comunicação SPI com microcontrolador PIC PIC16F877A
Interface LCD TFT Touch Screen de 3,5 polegadas com Raspberry Pi
Programação de microcontrolador AVR com pinos SPI
Interface do LCD gráfico Nokia 5110 com o Arduino

Trabalho da SPI

Um SPI tem uma comunicação mestre / escravo usando quatro linhas. Um SPI pode ter apenas um mestre e vários escravos. Um mestre é geralmente um microcontrolador e os escravos podem ser um microcontrolador, sensores, ADC, DAC, LCD etc.

Abaixo está a representação do diagrama de blocos de SPI Master com Single Slave.

O SPI segue as quatro linhas MISO, MOSI, SS e CLK

MISO (Master in Slave Out) - A linha Slave para enviar dados ao mestre.
MOSI (Master Out Slave In) - A linha Master para enviar dados aos periféricos.
SCK (Serial Clock) - Os pulsos de clock que sincronizam a transmissão de dados gerados pelo mestre.
SS (Slave Select) - O mestre pode usar este pino para habilitar e desabilitar dispositivos específicos.

Mestre SPI com vários escravos

Para iniciar a comunicação entre o mestre e o escravo, precisamos definir o pino Slave Select (SS) do dispositivo necessário para LOW, para que ele possa se comunicar com o mestre. Quando está alto, ele ignora o mestre. Isso permite que você tenha vários dispositivos SPI compartilhando as mesmas linhas MISO, MOSI e CLK de mestre. Como você pode ver na imagem acima, existem quatro escravos em que o SCLK, MISO, MOSI são comuns conectados ao mestre e o SS de cada escravo é conectado separadamente aos pinos SS individuais (SS1, SS2, SS3) do mestre. Ao definir o pino SS obrigatório BAIXO, um mestre pode se comunicar com esse escravo.

Pinos SPI no Arduino UNO

A imagem abaixo mostra os pinos SPI presentes no Arduino UNO (na caixa vermelha).

Linha SPI	Pin no Arduino
MOSI	11 ou ICSP-4
MISSÔ	12 ou ICSP-1
SCK	13 ou ICSP-3
SS	10

Usando SPI no Arduino

Antes de iniciar a programação para comunicação SPI entre dois Arduinos. Precisamos aprender sobre a biblioteca Arduino SPI usada no Arduino IDE.

A biblioteca está incluído no programa para usar as seguintes funções para comunicação SPI.

1. SPI.begin ()

USO: Para inicializar o barramento SPI definindo SCK, MOSI e SS para saídas, puxando SCK e MOSI para baixo e SS para alto.

2. SPI.setClockDivider (divider)

USO: Para definir o divisor de relógio SPI em relação ao relógio do sistema. Os divisores disponíveis são 2, 4, 8, 16, 32, 64 ou 128.

Divisores:

SPI_CLOCK_DIV2
SPI_CLOCK_DIV4
SPI_CLOCK_DIV8
SPI_CLOCK_DIV16
SPI_CLOCK_DIV32
SPI_CLOCK_DIV64
SPI_CLOCK_DIV128

3. SPI.attachInterrupt (manipulador)

USO: Esta função é chamada quando um dispositivo escravo recebe dados do mestre.

4. SPI.transfer (val)

USO: Esta função permite enviar e receber dados simultaneamente entre mestre e escravo.

Portanto, agora vamos começar com uma demonstração prática do protocolo SPI no Arduino. Neste tutorial usaremos dois arduino, um como mestre e outro como escravo. Ambos os Arduino são conectados com um LED e um botão de pressão separadamente. O LED mestre pode ser controlado usando o botão do Arduino escravo e o LED do Arduino escravo pode ser controlado pelo botão do Arduino mestre usando o protocolo de comunicação SPI presente no arduino.

Componentes necessários para comunicação Arduino SPI

Arduino UNO (2)
LED (2)
Botão (2)
Resistor 10k (2)
Resistor 2,2k (2)
Tábua de pão
Fios de conexão

Diagrama de Circuito de Comunicação Arduino SPI

O diagrama de circuito abaixo mostra como usar o SPI no Arduino UNO, mas você pode seguir o mesmo procedimento para a comunicação do Arduino Mega SPI ou para a comunicação do Arduino nano SPI. Quase tudo permanecerá o mesmo, exceto o número do pino. Você tem que verificar a pinagem do Arduino nano ou mega para encontrar os pinos SPI do Arduino nano e os pinos do Mega do Arduino, uma vez que você tenha feito tudo o resto será o mesmo.

Eu construí o circuito mostrado acima sobre uma placa de ensaio, você pode ver a configuração do circuito que usei para testar abaixo.

Como programar o Arduino para comunicação SPI:

Este tutorial tem dois programas, um para o Arduino mestre e outro para o Arduino escravo. Programas completos para ambos os lados são fornecidos no final deste projeto.

Explicação da programação mestre do Arduino SPI

1. Em primeiro lugar, precisamos incluir a biblioteca SPI para usar as funções de comunicação SPI.

#incluir

2. Na configuração vazia ()

Iniciamos a comunicação serial na taxa Baud 115200.

Serial.begin (115200);

Conecte o LED ao pino 7 e pressione o botão ao pino 2 e defina os pinos OUTPUT e INPUT respectivamente.

pinMode (ipbutton, INPUT); pinMode (LED, SAÍDA);

Em seguida, começamos a comunicação SPI

SPI.begin ();

Em seguida, configuramos o Clockdivider para comunicação SPI. Aqui, definimos o divisor 8.

SPI.setClockDivider (SPI_CLOCK_DIV8);

Em seguida, defina o pino SS como HIGH, pois não iniciamos nenhuma transferência para o arduino escravo.

digitalWrite (SS, HIGH);

3. Em loop vazio ():

Lemos o status do pino do botão de pressão conectado ao pino 2 (Master Arduino) para enviar esses valores ao escravo Arduino.

buttonvalue = digitalRead (ipbutton);

Defina a lógica para definir o valor x (a ser enviado para o escravo) dependendo da entrada do pino 2

if (valor do botão == ALTO) { x = 1; } mais { x = 0; }

Antes de enviar o valor, precisamos BAIXAR o valor de seleção do escravo para iniciar a transferência do mestre para o escravo.

digitalWrite (SS, LOW);

Aí vem o passo importante, na instrução a seguir enviamos o valor do botão de ação armazenado na variável Mastersend para o arduino escravo e também recebemos o valor do escravo que será armazenado na variável Mastereceive .

Mastereceive = SPI.transfer (Mastersend);

Depois disso, dependendo do valor de Mastereceive, ligaremos ou desligaremos o LED Master Arduino.

if (Mastereceive == 1) { digitalWrite (LED, HIGH); // Define o pino 7 HIGH Serial.println ("Master LED ON"); } else { digitalWrite (LED, LOW); // Define o pino 7 LOW Serial.println ("Master LED OFF"); }

Nota: Usamos serial.println () para visualizar o resultado no Serial Motor do Arduino IDE. Confira o vídeo no final.

Explicação de programação do Arduino SPI Slave

1. Em primeiro lugar, precisamos incluir a biblioteca SPI para usar as funções de comunicação SPI.

#incluir

2. Na configuração vazia ()

Iniciamos a comunicação serial na taxa Baud 115200.

Serial.begin (115200);

Conecte o LED ao pino 7 e pressione o botão ao pino 2 e defina os pinos OUTPUT e INPUT respectivamente.

pinMode (ipbutton, INPUT); pinMode (LED, SAÍDA);

O passo importante aqui são as seguintes declarações

pinMode (MISO, OUTPUT);

A instrução acima define MISO como OUTPUT (tem que enviar dados para Master IN). Assim, os dados são enviados via MISO do Slave Arduino.

Agora ligue o SPI no modo escravo usando o registro de controle SPI

SPCR - = _BV (SPE);

Em seguida, ligue a interrupção para comunicação SPI. Se um dado for recebido do mestre, a rotina de interrupção é chamada e o valor recebido é obtido do SPDR (Registro de dados SPI)

SPI.attachInterrupt ();

O valor do master é retirado do SPDR e armazenado na variável Slavereceived . Isso ocorre na seguinte função de rotina de interrupção.

ISR (SPI_STC_vect) { Slavereceived = SPDR; recebido = verdadeiro; }

3. Em seguida, em void loop (), configuramos o LED do Arduino Slave para LIGAR ou DESLIGAR dependendo do valor recebido do Escravo.

if (Slavereceived == 1) { digitalWrite (LEDpin, HIGH); // Define o pino 7 como HIGH LED ON Serial.println ("Slave LED ON"); } else { digitalWrite (LEDpin, LOW); // Define o pino 7 como LED LOW OFF Serial.println ("Slave LED OFF"); }

Em seguida, lemos o status do botão Slave Arduino e armazenamos o valor no Slavesend para enviar o valor para o Arduino Mestre, atribuindo valor ao registro SPDR.

buttonvalue = digitalRead (botão); if (valor do botão == ALTO) {x = 1; } mais {x = 0; } Slavesend = x; SPDR = envio escravo;

Nota: Usamos serial.println () para visualizar o resultado no Serial Motor do Arduino IDE. Confira o vídeo no final.

Como o SPI funciona no Arduino? - Vamos testar!

Abaixo está a imagem da configuração final para comunicação SPI entre duas placas Arduino.

Quando o botão no lado mestre é pressionado, o LED branco no lado escravo liga.

E quando o botão no lado escravo é pressionado, o LED vermelho no lado mestre acende.

Você pode conferir o vídeo abaixo para ver a demonstração da comunicação do Arduino SPI. Se você tiver alguma dúvida, deixe-a na seção de comentários ou use nossos fóruns.