Dominando a comunicação serial com Arduino

Ao trabalhar em grandes projetos Arduino, é bastante comum ficar sem pinos disponíveis para conectar componentes. Digamos que você queira conectar vários sensores/atuadores com a necessidade urgente de ainda preservar pinos extras para alimentar um módulo de exibição com fome de pinos.

A menos que você faça alguma mágica, às vezes é difícil lidar com todas essas conexões em uma única placa Arduino - especialmente quando você decide usar placas menores porque precisa de espaço. É aí que a comunicação serial entra em ação.

Vamos explorar o que é comunicação serial e as maneiras pelas quais você pode configurá-la com o Arduino para tarefas como processamento distribuído e integração geral.

O que é comunicação serial?

A comunicação serial é um método de envio e recebimento de dados entre dois ou mais dispositivos eletrônicos, um bit por vez em uma única linha de comunicação. Como o nome sugere, os dados estão sendo enviados em "série

".

Até mesmo ser capaz de fazer upload de esboços para sua placa Arduino favorita usa comunicação serial via USB.

Protocolos de comunicação serial no Arduino

As placas Arduino são incrivelmente versáteis e podem se comunicar com uma ampla gama de dispositivos. Eles suportam quatro protocolos de comunicação serial: Soft Serial, SPI (Serial Peripheral Interface), UART padrão (Receptor-Transmissor Assíncrono Universal) e I2C (Circuito Inter-Integrado). Para mais detalhes, confira nosso guia completo sobre como funcionam as comunicações seriais UART, SPI e I2C.

Este tutorial usa esboços básicos para mostrar como você pode configurar uma conexão serial entre duas placas Arduino Uno usando vários protocolos. Adapte o código para atender aos seus requisitos específicos.

SPI (Interface Periférica Serial)

SPI é um protocolo de comunicação serial síncrona que permite comunicação de alta velocidade entre microcontroladores e dispositivos periféricos. Este protocolo requer quatro fios para comunicação: SCK (relógio serial), MOSI (Master Out Slave In), MISSÔ (Master In Slave Out) e SS (Seleção de Escravo).

O SPI.h A biblioteca é muito útil para esse tipo de comunicação e deve ser incluída na parte superior do seu esboço.

#incluir

Aqui estão os pinos SPI na placa Arduino Uno:

Após inicializar a comunicação serial, você precisará configurar os pinos de comunicação.

vazioconfigurar(){
SPI.começar(115200);
// Define modos de pinos para SS, MOSI, MISO e SCK
pinMode(SS, SAÍDA);
pinMode(MOSI, SAÍDA);
pinMode(MISSÔ, ENTRADA);
pinMode(SCK, SAÍDA);
// Define o pino de seleção do escravo (SS) como alto para desabilitar o dispositivo escravo
digitalWrite(SS, ALTO);
}

O sinal SS é usado para informar ao dispositivo escravo quando os dados estão sendo transferidos.

// Seleciona o escravo
digitalWrite(SS, BAIXO);
// Envia dados para o dispositivo escravo
SPI.transferir(dados);
// Desmarca o dispositivo escravo
digitalWrite(SS, ALTO);

Veja como conectar duas placas Arduino usando SPI.

Código da placa master:

#incluir
constint slaveSelectPin = 10;
vazioconfigurar(){
SPI.começar(115200);
pinMode(slaveSelectPin, SAÍDA);
}
vaziolaço(){
digitalWrite(slaveSelectPin, BAIXO);
SPI.transferir('H');
digitalWrite(slaveSelectPin, ALTO);
atraso(1000);
}

Código da placa slave:

#incluir
constint slaveSelectPin = 10;
vazioconfigurar(){
SPI.começar(115200);
pinMode(slaveSelectPin, SAÍDA);
}
vaziolaço(){
se (leitura digital(slaveSelectPin) == BAIXO) {
Caracteres dados recebidos = SPI.transferir('EU');
Serial.println(dados recebidos);
 }
}

Certifique-se de que seus dispositivos compartilhem um terreno comum para uma configuração adequada.

UART (Receptor-Transmissor Assíncrono Universal)

UART é um protocolo de comunicação serial assíncrono que permite a comunicação entre dispositivos utilizando apenas dois fios: TX (Transmitir) e RX (Receber). O UART é comumente usado para comunicação com dispositivos como módulos GPS, módulos Bluetooth e outros microcontroladores. Toda placa Arduino vem equipada com pelo menos uma porta para UART.

Os pinos UART em placas Arduino populares incluem:

Você pode obter a tabela completa em Documentação online do Arduino sobre comunicação serial.

Primeiro, conecte suas placas assim:

Em seguida, use este código para a placa do remetente:

vazioconfigurar(){
Serial.começar(9600);
}
vaziolaço(){
// Envia uma mensagem via serial a cada segundo
Serial.println("Olá da placa do remetente!");
atraso(1000);
}

Código da placa receptora:

vazioconfigurar(){
Serial.começar(9600);
}
vaziolaço(){
// Verifica se há algum dado entrando
se (Serial.disponível() > 0) {
// Lê os dados recebidos e os imprime no monitor serial
Corda entradaDados = Serial.readString();
Serial.println(incomingData);
 }
}

O Arduino Uno opera em um nível lógico de 5V, enquanto a porta RS232 de um computador usa um nível lógico de +/-12V.

Conectar diretamente um Arduino Uno a uma porta RS232 pode danificar sua placa.

I2C (Circuito Interintegrado)

I2C é um protocolo de comunicação serial síncrona que permite a comunicação entre vários dispositivos usando apenas dois fios: SDA (Serial Data) e SCL (Serial Clock). I2C é comumente usado para comunicação com sensores, EEPROMs e outros dispositivos que precisam transferir dados em distâncias curtas.

Os pinos I2C no Arduino Uno são SDA (A4) e SCL (A5).

Vamos criar um programa simples para estabelecer uma conexão entre duas placas Arduino usando comunicação I2C. Mas primeiro, conecte suas placas assim:

Código da placa master:

#incluir
vazioconfigurar(){
Arame.começar(); // junta-se ao barramento I2C como mestre
Serial.começar(9600);
}
vaziolaço(){
Arame.startTransmission(9); // transmite para o dispositivo escravo com endereço 9
Arame.escrever('a'); // envia 'a' byte para dispositivo escravo
Arame.endTransmission(); // para de transmitir
atraso(500);
}

Código da placa slave:

#incluir
vazioconfigurar(){
Arame.começar(9); // junta-se ao barramento I2C como escravo com endereço 9
Arame.ao receber(receberEvento);
Serial.começar(9600); 
}
vaziolaço(){
atraso(100);
}
vazioreceberEvento(int bytes){
enquanto(Arame.disponível()) { // percorre todos os bytes recebidos
Caracteres Byte recebido = Arame.ler(); // lê cada byte recebido
Serial.println(Byte recebido); // imprime o byte recebido no monitor serial
 }
}

O que é SoftwareSerial?

A biblioteca Arduino SoftwareSerial foi desenvolvida para emular a comunicação UART, permitindo a comunicação serial através de dois pinos digitais quaisquer nas placas Arduino. É útil quando o hardware UART já está em uso por outros dispositivos.

Para configurar o SoftwareSerial, primeiro inclua a biblioteca SoftwareSerial no esboço.

#incluir

Em seguida, crie uma instância do objeto SoftwareSerial especificando o RX e Texas pinos a serem usados ​​para comunicação.

SoftwareSerialmySerial(2, 3); // pinos RX, TX

Aqui está um código de exemplo para Arduino que demonstra o uso de SoftwareSerial:

#incluir
SoftwareSerialmySerial(2, 3); // pinos RX, TX
vazioconfigurar(){
Serial.começar(9600); // inicia a serial do hardware
 mySerial.começar(9600); // inicia soft serial
}
vaziolaço(){
se (meuSerial.disponível()) {
Serial.escrever(meuSerial.ler()); // envia os dados recebidos para a serial do hardware
 }
se (Serial.disponível()) {
 mySerial.escrever(Serial.ler()); // envia dados do serial do hardware para o soft serial
 }
}

A Biblioteca Serial

A biblioteca Serial é uma poderosa ferramenta do Arduino que permite a comunicação entre o microcontrolador e um computador ou outros dispositivos através de uma conexão serial. Algumas funções comuns incluem:

Taxa de transmissão e formato de dados seriais

A taxa de transmissão refere-se à velocidade na qual os dados são transferidos pela conexão serial. Representa o número de bits que são transmitidos por segundo. A taxa de transmissão deve ser igual nos dispositivos emissor e receptor, caso contrário, a comunicação pode ser distorcida ou não funcionar. Taxas de transmissão comuns para Arduino incluem 9600, 19200, 38400 e 115200.

O formato de dados serial refere-se à estrutura dos dados enviados pela conexão serial. Existem três componentes principais no formato de dados seriais: bits de início, bits de dados e bits de parada.

• Bits de dados: O número de bits usados ​​para representar um único byte de dados.
• Paridade: Um bit opcional usado para verificação de erros. Pode ser definido como paridade nenhuma, par ou ímpar, dependendo dos requisitos do canal de comunicação.
• Bits de parada: O número de bits usados ​​para sinalizar o fim de um byte de dados.

O formato dos dados precisa ser o mesmo nos dispositivos de transmissão e recepção para garantir a comunicação adequada. Aqui está um exemplo de como você pode definir formatos de dados específicos:

vazioconfigurar(){
// Configura a comunicação serial com taxa de transmissão de 9600, 8 bits de dados, sem paridade e 1 bit de parada
Serial.começar(9600, SERIAL_8N1); 
}

Aqui, SERIAL_8N1 representa o formato de dados com 8 bits de dados, sem paridade e 1 pare um pouco. Outras opções como SERIAL_7E1, SERIAL_8O2, etc., podem ser usados ​​dependendo dos requisitos específicos do projeto.

conversa em série

As placas Arduino fornecem várias opções de comunicação serial que permitem a troca de dados eficiente e confiável entre os dispositivos. Ao entender como configurar protocolos de comunicação serial no Arduino IDE, você pode aproveitar o poder do processamento distribuído ou reduzir bastante o número de fios usados ​​em seus projetos.