Comunicação entre Arduinos: SPI

This tutorial is not available in English

Em algumas situações é interessante configurar dois Arduinos para trocar informações entre si. Neste tutorial, iremos programar duas placas para se comunicarem entre si via protocolo serial SPI na configuração Master emissor/Slave receptor. Utilizaremos a bliblioteca SPI.
Nesse exemplo, ao pressionar o botão conectado à placa Master, o estado do led conectado à placa Slave será alterado.
O protocolo serial síncrono SPI utiliza quatro fios (SCK - Clock, MOSI - Master Output/Slave Input, MISO - Master Input/Slave Output e SS - Slave Select) para realizar uma comunicação full duplex permitindo que ambos os Arduinos possam enviar e receber dados ao mesmo tempo. O protocolo permite que um mestre se conecte com múltiplos escravos, para isso cada escravo deve possuir um pino Slave Select definido no mestre.
Desta maneira, para selecionar o módulo escravo que irá receber a informação, basta colocar o pino seletor do dispositivo desejado em nível lógico alto.

Para isso precisaremos de:

Confira na imagem ao lado como realizar as conexões de cada BlackBoard.

Agora que você já montou todo o circuito, é necessário programar cada placa com seu código. Neste momento, é importante que você verifique se está gravando a BlackBoard correta, por isso recomendamos que conecte e programe uma placa por vez. Desta forma você não irá se confundir com as portas COM.

Código para a BlackBoard Master (conectada ao botão):

/*
      RoboCore - Tutorial Comunicacao entre Arduinos: SPI - (Master)
                                                        (30/05/2015)

  Escrito por Marcelo Farias.

  Exemplo de como comunicar Arduinos utilizando o protocolo SPI.

  Altera o estado do LED conectado a placa Slave quando o botao ligado
  a placa Master for pressionado.

  Na placa Master foi utilizado um botao conectado ao pino 4, com o
  resistor de pullup interno da placa acionado e realizou-se um debounce
  em software. Na placa Slave foi utilizado um LED conectado ao pino 7.

  Referencias:
  Exemplo Debounce - https://www.arduino.cc/en/Tutorial/Debounce
  Forum = http://www.gammon.com.au/spi
*/

#include "SPI.h"

#define buttonPin 4 // numero do pino onde o botao esta conectado
#define ssPin 10 // pino seletor do slave

boolean buttonState;             // estado atual do botao
boolean lastButtonState = LOW;   // valor da ultima leitura do botao
boolean ledState = HIGH;         // estado atual do LED

// as variaveis a seguir sao do tipo long por conta que o tempo, medido 
// em milessegundos alcancara rapidamente um numero grande demais para 
// armazenar em uma variavel do tipo int
unsigned long lastDebounceTime = 0;  // tempo da ultima modificacao do estado do LED

// tempo de debounce; aumentar se o LED oscilar; espera-se que o LED acenda
// apenas se o botao for pressionado por mais de 50ms
unsigned long debounceDelay = 50;    

void setup() {
  SPI.begin();  // ingressa ao barramento SPI
  
  // configura o pino do botao como entrada com resistor de pullup interno
  pinMode(buttonPin, INPUT_PULLUP);
  
  pinMode(ssPin, OUTPUT);  // configura o pino seletor do slave como saida
  digitalWrite(ssPin, HIGH);  // coloca o pino seletor do slave em nivel alto
}

void loop() {
  // le o estado do botao e salva em uma variavel local
  int reading = digitalRead(buttonPin);

  // verifica se voce apenas apertou o botao (i.e. se a entrada foi de LOW 
  // to HIGH), e se ja esperou tempo suficiente para ignorar qualquer ruido

  // se a entrada foi alterada devido ao ruido ou botao ter sido pressionado:
  if (reading != lastButtonState) {
    // reseta o tempo do debounce
    lastDebounceTime = millis();
  }
  
  if ((millis() - lastDebounceTime) > debounceDelay) {
    // qualquer que seja a leitura atual, ela se manteve por um tempo maior
    // que o nosso debounce delay, então atualizemos o estado atual:

    // se o estado do botao foi alterado:
    if (reading != buttonState) {
      buttonState = reading;

      // apenas altera o estado do LED se o novo estado do botao e HIGH
      if (buttonState == HIGH) {
        ledState = !ledState;

         // coloca o pino seletor do slave em nivel baixo iniciando a transmissao
        digitalWrite(ssPin, LOW);
        
        SPI.transfer(ledState); // envia um byte contendo o estado do LED
        
        // coloca o pino seletor do slave em nivel alto finalizando a transmissao
        digitalWrite(ssPin, HIGH); 
      }
    }
  }
  
  // salva a leitura. No proximo laco este sera o ultimo 
  // estado do botao (lastButtonState)
  lastButtonState = reading;
}

Código para a BlackBoard Slave (conectada ao LED):

/*
      RoboCore - Tutorial Comunicacao entre Arduinos: SPI -(Slave)
                                                       (30/05/2015)

  Escrito por Marcelo Farias.

  Exemplo de como comunicar Arduinos utilizando o protocolo SPI.

  Altera o estado do LED conectado a placa Slave quando o botao ligado
  a placa Master for pressionado.

  Na placa Master foi utilizado um botao conectado ao pino 4, com o
  resistor de pullup interno da placa acionado e realizou-se um debounce
  em software. Na placa Slave foi utilizado um LED conectado ao pino 7.

  Referencias:
  Exemplo Debounce - https://www.arduino.cc/en/Tutorial/Debounce
  Forum = http://www.gammon.com.au/spi
*/

#include "SPI.h"

#define ledPin 7 // numero do pino onde o LED esta conectado

char received_data; // armazena o dado recebidos
volatile boolean received_flag; // flag de recebimento de dado

void setup() {
  // inicia a SPI no modo escravo
  SPCR |= bit (SPE);
  
  // configura o pino MISO como saida
  pinMode(MISO, OUTPUT);
  
  // prepara o flag de recebimento para interrupcao
  received_flag = false;
  
  // liga as interrupcoes
  SPI.attachInterrupt();

  pinMode(ledPin, OUTPUT);  // configura o pino do LED como saida
}

void loop() {
  // se o flag de recebimento for verdadeiro:
  if (received_flag){
    // se o byte recebido for igual a 0, apaga o LED
    if (received_data == 0) {
      digitalWrite(ledPin, LOW);
    }

    // se o byte recebido for igual a 1 acende o LED
    if (received_data == 1) {
      digitalWrite(ledPin, HIGH);
    }

    // limpa o flag de recebimento
    received_flag = false;
  }
}

// Rotina de interrupcao do SPI
ISR (SPI_STC_vect) {
  // le e salva o byte do Registrador de dados da SPI
  received_data = SPDR; 

  // seta o flag de recebimento para que o dado recebido 
  // seja processado no proximo loop
  received_flag = true;
}

Agora basta alimentar ambas as placas que tudo deve funcionar perfeitamente. Aperte o botão da BlackBoard Master e o LED conectado a placa Slave deve acender. Se você apertar novamente o mesmo deve apagar.

Comments

To make comments you must be logged in. Login.

You are not registered yet? Register Now!

zelmiroalves
date

Sent 2022-07-02 17:18:59

Seria possível dois dispositivos spi em um arduíno uno por exemplo.  Dois i2c já fiz com displays

luan.ferreira
date

Sent 2022-07-04 09:31:29
zelmiroalves

Olá! Sim, é possível conectar vários dispositivos ao Arduino usando a comunicação SPI, pois a comunicação SPI aceita até 128 dispositivos conectados no mesmo barramento. Entretanto, este número costuma ser menor em placas Arduino, devido à limitação do números de pinos digitais que a placa possuir, pois mesmo que os pinos MISO, MOSI e SCK sejam compartilhados nas conexão dos dispositivos "SLAVE", é necessário um pino digital para ser o SS ("Slave Select") de cada dispositivo conectado.

luan.ferreira
date

Sent 2022-07-04 15:43:15
zelmiroalves

Apenas uma correção, a limitação de 128 dispositivos é para o protocolo I2C. Na comunicação SPI, os dispositivos escravos são selecionados através do sinal SS (Slave Select), então a limitação costuma estar na quantidade de pinos disponíveis para o controle do barramento. Pedimos desculpas pelo erro.

Janchietar
date

Sent 2020-03-30 12:13:47

Olá, Giovanni5, muitíssimo obrigado pela pronta resposta. Agradeço o envio do link para projeto que talvez possa me ajudar. Vou entrar lá e verificar. Um fraterno abraço à distância em tempos de pandemia.

Janchietar
date

Sent 2020-03-29 23:14:21

Olá, gostei desse artigo! Eu tenho um projeto que precisa fazer a comunicação entre dois Arduinos (na verdade um Arduino e um Arduino Nano), mas eles estarão distantes um do outro de uma distância de uns 5 metros, porém eu não posso passar fios nesse trajeto. Pensei em usar o seu sketch, porém tendo em cada microcontrolador um tranceiver NRF24L01 para a comunicação à distância. Você tem algum projeto com essa configuração. Fico agradecido, antecipadamente, se você me sugerir algo para ler ou me indicar um projeto de vocês. Abraço fraterno.

Giovanni5

Sent 2020-03-30 09:25:29
Janchietar

Infelizmente não temos nenhum tutorial, documento ou projeto utilizando este componente, já que não trabalhamos com ele. Entretanto, talvez o tutorial a seguir possa te ajudar em seu projeto, https://howtomechatronics.com/tutorials/arduino/how-to-build-an-arduino-wireless-network-with-multiple-nrf24l01-modules/ .

Dougmeca
date

Sent 2019-08-02 13:30:27

Olá, por favor, poderiam me tirar uma dúvida importante. Eu quero utilizar o shield ethernet, porém sem estar acoplado ao arduino mega. Eu sei que o pino SS do arduino mega é o 53, porém o arduino utiliza o pinto 10 também, visto que o pino 53 não é conectado ao shield. Eu não vejo em nenhum lugar a alocação do pino 10 como SS para o shield, e gostaria de saber se é possível eu trocar esse pino e colocar qualquer outro pino como SS para o shield ethernet. Obrigado!!

Giovanni5

Sent 2019-08-02 16:08:24
Dougmeca

O circuito do Shield Ethernet que fabricamos e vendemos em nosso site, por exemplo, quando acoplado à uma placa da plataforma Arduino, possui seu pino 10 conectado diretamente à porta responsável pelo Slave Select. Portanto, não é possível realizar essa alteração quando as placas estão acopladas. Você deve ser capaz de alterar essa porta para trabalhar com o Shield desconectado, porém seria necessária uma alteração nas bibliotecas responsáveis pela comunicação com o Shield, o que não é recomendado, já que isto pode ocasionar em um mal funcionamento nas mesmas.

Heloiso
date

Sent 2018-03-23 00:45:58

Não funciona no mega 2560.. Pode me ajudar ?

Francois

Sent 2018-03-23 11:17:41
Heloiso

O Arduino Mega 2560 utiliza os pinos 50 a 53 para a comunicação SPI. Adapte as ligações para os respectivos pinos e teste o código. Para mais informações sobre a pinagem SPI nas diferentes placas Arduino, acesse https://www.arduino.cc/en/Reference/SPI

wender_fatec
date

Sent 2017-03-26 18:44:29

Boa noite! Todas bibliografias que consultei até o momento consta que a comunicação SPI envia e recebe dados de oito bits. Caso eu queira enviar e/ou receber o valor de uma variável analogica qualquer ou uma palavra é possível? Se sim vocês poderiam sugerir uma forma de enviar ou receber este tipo de dados?

MarceloFarias
date

Sent 2017-03-27 09:26:24
wender_fatec

Você pode particionar seu valor em 2 ou mais bytes. Definindo qual seria o byte mais significativo e o menos significativo. Desta forma, quando o Arduíno receber do outro lado, basta unir os bytes na ordem certa para obter o valor correto. 
Dê uma olhada no link da documentação da biblioteca do Arduino: https://www.arduino.cc/en/Reference/SPITransfer e fique atento a opção: transfer16().

wender_fatec
date

Sent 2016-11-04 02:14:28

Grato pelo retorno referente a duvida anterior. Acho que a referencia de mestre e escravo na figura acima está trocada. E estou tendo uma duvida quanto ao pino SS do escravo que pelo que eu vi no programa não está declarado . Gostaria de saber em que documentação eu consigo obter informações quanto aos registradores que vocês utilizaram no programa.

MarceloFarias
date

Sent 2016-11-04 10:18:01
wender_fatec

A imagem já foi atualizada, grato pela observação. A não declaração do pino 10 no código do escravo se dá justamente para que o Arduino escravo se comporte como tal. Conforme o Header dos códigos acima, nesse link você encontra maiores informações sobre a comunicação SPI com arduino: http://www.gammon.com.au/spi, inclusive a informação sobre o pino 10.

wender_fatec
date

Sent 2016-10-30 19:53:41

Desde já estou grato quanto ao retorno referente aos comentários anteriores. Estou tentando fazer uma aplicação onde comunique um arduino(mestre) se comunique com outros arduinos(2 ou 3) e com o enc28j60. Estou tentando colocar em pratica esta aplicação com o material do arduino.cc . Porem estou tendo dificuldade em filtrar as informações e principalmente colocar em pratica. Vocês acham que é possível essa aplicação e onde conseguiria informações voltadas a configuração da comunicação SPI e como intercalar a comunicação SPI do enc28j60 e a dos escravos?
Grato
Wenderson

MarceloFarias
date

Sent 2016-10-31 10:24:29
wender_fatec

Acredito que seja possível sim. Pois cada dispositivo escravo (Seja um Arduino ou outro módulo que se comunique via SPI) tem um pino seletor que define se este módulo receberá ou não a informação vinda do Arduino Mestre. Logo, basta você colocar um pino seletor para cada periférico e colocar em nível lógico alto apenas o que você deseja que receba a informação.

wender_fatec
date

Sent 2016-09-24 12:13:04

Bom dia. Esse programa funciona para comunicar um Arduíno uno com blackboard?

hallszombie
date

Sent 2016-09-24 12:57:20
wender_fatec

Como o controlador das placas é igual, não há problema em comunicar um Arduino e uma Blackboard.

wender_fatec
date

Sent 2016-09-19 00:05:29

wender_fatec
date

Sent 2016-09-19 00:07:54
wender_fatec

Mas no caso estou tentando usar um PIC com modulo SPI, porém não estou tendo sucesso nem para ligar um led.

MarceloFarias
date

Sent 2016-09-19 10:44:04
wender_fatec

Infelizmente esse tutorial foi desenvolvido para placas Arduino que são baseadas em microcontroladores atmega então não sabemos como isso funcionaria para microcontroladores PIC.