Interface periférica em série em Arduino

Arduino é um quadro de desenvolvimento eletrônico que é executado usando um microcontrolador. Ele processa instruções e gera a saída desejada. A comunicação desempenha um papel importante durante o processamento do código Arduino. Para fazer isso, Arduino tem vários protocolos de comunicação como USART, I2C e SPI. Para ler mais sobre os protocolos de comunicação em detalhes, clique aqui. Hoje discutiremos como o SPI (interface periférica em série) é usada em Arduino.

Interface periférica em série (SPI)

A interface periférica em série (SPI) é um protocolo de dados serial síncronos usado por microcontroladores de arduino para fins de comunicação com um ou mais dispositivos periféricos rapidamente a distâncias curtas. Também pode ser usado para comunicação entre dois microcontroladores.

SPI é uma comunicação duplex completa, o que significa que pode enviar e ler dados ao mesmo tempo. Entre os três protocolos de comunicação (USART, SPI e I2C) em Arduino SPI é mais rápido. O SPI possui aplicativos onde é necessária alta taxa de dados, como exibir texto nas telas ou escrever dados no cartão SD.

SPI funciona usando quatro linhas:

• SCK: Sinal do relógio que sincronizam a transferência de dados entre dispositivos mestre e escravo.
• MISSÔ: (Mestre em escravo) ou miso é uma linha de dados para escravo que pode enviar dados de volta ao mestre.
• Mosi: (Mestre escravo) ou MOSI é uma linha de dados para o mestre enviar dados para dispositivos escravos e periféricos.
• SS: (Seleção de escravos) É a linha usada pelo mestre para selecionar um dispositivo de escravo específico. Informa o dispositivo escravo para quais dados serão enviados ou recebidos.

Atualizar: De acordo com a documentação oficial do Arduino, o SPI em Arduino não suporta mais essas terminologias. Abaixo da tabela mostra as novas terminologias:

Pinagem spi em arduino uno

O protocolo SPI é suportado por várias placas Arduino aqui, discutimos o suporte do Arduino Uno para o SPI. A seguir estão os pinos usados ​​por Arduino Uno para comunicação periférica em série.

SPI na configuração de escravos mestre

Conectar um dispositivo mestre ao escravo único é simples, apenas temos que conectar os dois com o mesmo pino. Uma vez que o dispositivo mestre e escravo esteja conectado como mostrado na imagem abaixo. Primeiro, temos que definir o SS (linha de seleção de escravos) no dispositivo mestre como baixo. Permanecerá baixo durante a transmissão de dados. Linha SS baixa prepare escravo para enviar ou receber dados. Depois que o SS é baixo, o dispositivo pode enviar dados usando a linha MOSI e pode produzir sinais de relógio para comunicação síncrona usando o pino SCLK.

SPI na configuração de escravo múltiplo mestre único

O SPI também suporta vários dispositivos de escravos, uma linha SS separada (seleção de escravos) é usada para cada escravo. Ao contrário de um único escravo aqui, o mestre precisa de uma linha SS separada para cada escravo. O trabalho de configuração de dispositivos escravos únicos e múltiplos é de alguma forma semelhante. Dispositivo mestre puxe a linha SS de escravo em particular para baixo, que informa o dispositivo escravo que o mestre vai enviar ou receber dados desse escravo.

A imagem a seguir ilustra a configuração de dispositivo escravo múltiplo mestre único.

A configuração da cadeia da margara é outra maneira de conectar vários dispositivos escravos. Onde o mestre não precisa de múltiplas linhas SS para cada escravo, na verdade, uma única linha SS está conectada ao primeiro dispositivo de escravo. Depois que o dispositivo mestre puxa a linha SS para baixo, ele envia sinais para todo o dispositivo escravo para estar pronto para comunicação no Pin Mosi. Em seguida, o dispositivo mestre envie dados para Mosi Pin do primeiro dispositivo escravo.

Ao mesmo tempo, o mestre envia um sinal de relógio no pino SCK. Os dados são enviados de um escravo para outro e o pino SS é definido tão baixo durante essa duração. O mestre deve enviar sinal de relógio suficiente para alcançá -lo até o último dispositivo de escravo. Os dados recebidos de um dispositivo escravo específico serão recebidos pelo mestre em seu pino miso.

A imagem a seguir ilustra a configuração da cadeia de margaridas.

Como programar a comunicação Arduino para SPI

Agora vamos pegar duas pranchas de Arduino e passar uma corda de uma placa Arduino, que é mestre para o segundo Arduino, que está atuando como escravo. Lembre -se de abrir duas janelas separadas do Arduino IDE antes de enviar o código, caso contrário, há uma grande chance de enviar o mesmo código em ambos os Arduino.

Antes de fazer o upload do código, selecione a porta COM na qual o Arduino está conectado. Ambos os Arduino devem ser conectados em portas COM separadas.

O circuito

Conecte duas placas Arduino, como mostradas no circuito abaixo. Certifique -se de conectar as duas placas ao GND e conectar todos os outros quatro pinos SPI do pino 10 a 13 dos dois Arduino.

Hardware

Abaixo está a imagem de hardware de duas placas Arduino conectadas ao PC usando o cabo USB.

Código mestre

/*Código mestre Arduino*/
#include /*biblioteca SPI incluída* /
Void Setup ()
Serial.começar (115200); /*Taxa de transmissão definida para comunicação serial*/
DigitalWrite (SS, alto); /*(SS) Selecionar linha de seleção desativada*/
Spi.começar(); /*A comunicação SPI começa*/
Spi.setClockDivider (spi_clock_div8); /*Relógio dividido por 8*/

Void Loop ()
char char_str; /*Variável definida para enviar dados*/
DigitalWrite (SS, baixo); /*(SS) Selecionar escravo ativado*/
para (const char * p = "linuxhint.Com \ r "; char_str =*p; p ++) /*string de teste enviado* /
Spi.transferência (char_str); /*Transferência spi começam*/
Serial.impressão (char_str); /*String é impressa*/

DigitalWrite (SS, alto);
Atraso (2000);

Aqui no código acima, incluímos a Biblioteca SPI para comunicação. Em seguida, começamos definindo a taxa de transmissão para ver a produção na linha de seleção de escravos do monitor serial está desativada usando a gravação digital. Para começar a comunicação SPI Spi.começar() é usado.

Na parte do loop do código, uma variável de char é definida para armazenar a string que vamos enviar escravos Arduino. Em seguida, uma string “Linuxhint.Com ” é definido que é transferido para o escravo Arduino usando o SPI.transferir(). Para ver a sequência de entrada no monitor serial Serial.imprimir() função é usada.

Código de escravos

/*Código de Arduino de escravos*/
#include /*biblioteca SPI incluída* /
buffer de char [50]; /*Buffer definido para armazenar string recebida de mestre*/
Índice de bytes volátil; /*Salvar dados da string*/
processo booleano volátil;
Void Setup ()
Serial.começar (115200);
pinmode (miso, saída); /*Miso definido como saída para enviar dados para master*/
Spcr | = _bv (spe); /*Spi no modo escravo ativo*/
índice = 0; /*Buffer vazio*/
processo = false;
Spi.anexinterrupt (); /*Ligue a interrupção*/

Isr (spi_stc_vect) /*rotina de interrupção spi* /
byte char_str = spdr; /*Leia o byte do SPI Data Register*/
if (índice < sizeof buffer)
buffer [index ++] = char_str; /*Dados salvos no índice de Buff de matriz*/
if (char_str == '\ r') /*verifique se a string termina* /
processo = true;


Void Loop ()
if (processo)
processo = false; /*Redefinição do processo*/
Serial.println (buffer); /*Matriz recebida impressa no monitor serial*/
índice = 0; /*Redefinir botão para zero*/

O código acima é carregado para escravos Arduino, onde começamos definindo três variáveis buffer, índice e processo. A variável buffer armazenará a sequência de entrada do mestre Arduino, enquanto o índice procurará o índice de elementos dentro da string e assim que toda a string for impressa, o processo interromperá o programa e reiniciará para zero. Depois disso, o escravo começará a receber dados do Master Arduino e será impresso no monitor serial.

Saída

A saída pode ser vista em duas janelas diferentes do Arduino IDE. A saída do mestre e do escravo Arduino é impresso no monitor serial.

Conclusão

A interface periférica em série é um importante protocolo de comunicação usado na programação Arduino que ajuda os usuários a controlar vários dispositivos usando uma única placa Arduino. O SPI é mais rápido que o USART e o protocolo I2C. Ele pode ser implementado em duas configurações diferentes mestre com escravo único ou múltiplos escravos. Este artigo fornece uma visão de como o Arduino pode ser conectado para comunicação SPI.