Comunicação serial Arduino via protocolo UART

Comunicação serial Arduino via protocolo UART Deixe um comentário

Como conectar dois Arduinos entre si? O que é o protocolo de comunicação UART? Nesse artigo vamos esclarecer como integrar Arduinos e utilizar a comunicação serial no Arduino.

Protocolos de comunicação

Quando trabalhamos com comunicação serial, podemos ter protocolos diferentes para fazer transferência de dados (bits). Mas por que há diferentes protocolos?

Basicamente, surgiram diferentes demandas durante os anos para, por exemplo, conectar vários dispositivos simultaneamente, fazer aplicações que sejam mais otimizadas e rápidas, enfim, cada protocolo de comunicação existente tem suas vantagens e desvantagens, sendo os principais de protocolos de comunicação serial: UART, I2C e SPI. Aqui o nosso foco será falar sobre o protocolo UART.

O que é UART?

Já sabemos que UART é um protocolo de comunicação, mas o que significa seu nome? UART é um acrônimo para Universal Asynchronous Receiver/Transmitter que significa em português algo como “Recebimento/Transmissor Universal Assíncrono”.

Dissecando esse nome, temos que esse protocolo permite fazer com que um dispositivo receba dados e outro transmita. Vale dizer logo de início que pela forma que UART foi estruturada, apenas dois dispositivos podem ser conectados entre si.

Continuando, UART é Universal pois permite a conexão entre diversos dispositivos e Assíncrono pois não apresenta clock, ou seja, não apresenta o sinal de relógio que coordenaria as ações entre dispositivos.

Para explicitar um pouco melhor o que é o clock, imagine o seguinte: dois cozinheiros irão fazer uma sopa, e eles se organizam da seguinte forma: o cozinheiro 1 precisa ferver a água na panela, o cozinheiro 2 irá cortar os vegetais e jogar na panela, depois volta o cozinheiro 1 que irá colocar macarrão, salgar a água e mexer um pouco a sopa, e por fim o cozinheiro 2 deve servir a sopa nos pratos.

Perceba que caso os cozinheiros não se organizem entre si e não mantenham um tempo de execução parecido, o cozinheiro 2 pode querer servir a sopa sem nem que o cozinheiro 1 tenha trazido o macarrão ainda. Por mais que esse exemplo seja extremamente lúdico, é fundamental que dispositivos conectados, assim como os cozinheiros, mantenham um tempo de execução de tarefas semelhante, ou seja, uma velocidade semelhante.

Essa velocidade que falamos chama-se taxa de transmissão ou baud rate, e precisa ser escrita no código de cada dispositivo um dos dois dispositivos.

Agora que entendemos o que UART significa, vamos ver de forma simplificada como ocorre a transmissão dos bits e o porquê da UART não precisar de clock para marcar o baud rate. Veja a imagem abaixo.

Esquemático da conexão UART
Esquemático da conexão UART

Essa é a conexão da UART, então temos dois dispositivos, onde o TX do dispositivo 1 que é o pino transmitter é conectado no pino RX do dispositivo 2, o receiver, e vice-versa. Além disso, os GNDs dos dispositivos precisam estar conectados.

Conexão serial Arduino via protocolo UART
Conexão serial Arduino via protocolo UART

Para exemplificar, vamos levar em consideração que iremos passar 8 bits (1 byte) do Arduino 1 para o 2. Na prática o que acontece é o seguinte, pelo fio que está no TX do Arduino 1 e RX do Arduino 2, a tensão estará alta, ou seja, aproximadamente 5V serão observados nessas portas.

Quando, via código, fazemos a instrução de enviar algum dado, a tensão vai para aproximadamente 0V. Quando isso acontece, marcamos o início da transmissão de dados. Agora, a tensão irá alternar entre alta e baixa de acordo com o bit que deseja ser passado. No final, haverá um stop bit que indica o fim da transmissão de dados. Veja a figura abaixo que ilustra todos esses processos.

Esquema da diferença de tensão durante a transmissão de dados
Esquema da diferença de tensão durante a transmissão de dados

Perceba que alguns bits estão pontilhados pois podem ser tanto 1 ou 0, ou seja, alta tensão ou baixa tensão.

O gráfico que temos acima codifica o caractere Z, seu valor decimal correspondente na tabela ASCII é 76, que em bits vale 0101 1010.

Agora que conhecemos o protocolo UART e como ele funciona, hora de colocar a mão no código!

Comunicação serial Arduino

Antes de partir diretamente para a conexão, é importante saber que a grande vantagem de utilizar dois Arduinos conectados é o maior aproveitamento de conexões. Em projetos com muitos componentes, uma placa como a Arduino Uno pode ficar sem pinos com bastante facilidade, então ter um outro Arduino adicionado ao projeto, possibilita adicionar mais funcionalidades ao mesmo.

Primeiro de tudo, é necessário conectar dois Arduinos Uno. Você pode conectar diferentes tipos de Arduinos como um Uno com um Mega ou com um Nano, etc. Basta que conecte o pino TX de cada um com o pino RX do outro. Feito isso, iremos conectar em um dos Arduinos, quatro botões, e em outro, um display OLED 0.96’ 128×64.

A ideia aqui é que faremos um projeto didático em que, a partir do clique de botões, iremos controlar um personagem que andará livremente pelo display. Para isso, é necessário fazer as seguintes conexões:

Projeto usando a comunicação serial Arduino
Projeto usando a comunicação serial Arduino

Os jumpers azul, laranja, ciano e roxo servem para as conexões dos botões, enquanto que os botões amarelo e verde são utilizados para conexão tipo I2C. Ademais, os pinos preto e vermelho estão para conexão de referência e alimentação.

Agora, vamos para o código. É importante que você já tenha algumas noções de como utilizar a comunicação serial na prática, para isso, confira nosso artigo Como usar o monitor serial do Arduino

O código do Arduino que enviará dados, aquele que possui um botão, é o seguinte:

// Declarando variáveis para os botões.
const int botaoBaixo = 5;
const int botaoEsquerda = 6;
const int botaoCima = 7;
const int botaoDireita = 4;

void setup() {
  // Inicialização do Serial.
  Serial.begin(9600);

  // Configurando os botões como entradas.
  pinMode(botaoBaixo, INPUT_PULLUP);
  pinMode(botaoEsquerda, INPUT_PULLUP);
  pinMode(botaoCima, INPUT_PULLUP);
  pinMode(botaoDireita, INPUT_PULLUP);

}

void loop() {
  // Verificando se os pinos dos botões recebem nível
  // lógico baixo, ou seja, botões foram pressionados.
  // De acordo com o botão pressionado, um caractere
  // correspondente é enviado para via UART.
  if(digitalRead(botaoBaixo) == LOW){
    Serial.write('b');
    delay(300);
  }
  else if(digitalRead(botaoEsquerda) == LOW){
    Serial.write('e');
    delay(300);
  }
  else if(digitalRead(botaoCima) == LOW){
    Serial.write('c');
    delay(300);
  }
  else if(digitalRead(botaoDireita) == LOW){
    Serial.write('d');
    delay(300);
  }
}

Para o Arduino que recebe os dados, que possui o display, o código é esse aqui:

// Inclusão das bibliotecas necessárias para uso do Display.
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// Configurando o objeto "display".
const byte SCREEN_WIDTH = 128; 
const byte SCREEN_HEIGHT = 64;
const int OLED_RESET = -1; 
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Coordenadas x e y do display.
int x = 0;
int y = 28;

void setup() {
  // Inicialização do Serial.
  Serial.begin(9600);

  // Inicialização do display.
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  

  // Limpando o buffer do display.
  display.clearDisplay();
  display.display();
  delay(500);

  // Impressão do personagem na posição inicial.
  display.setTextSize(3);
  display.setTextColor(WHITE);
  display.setCursor(x,y);
  display.write(2);
  display.display();
}

void loop() {
  // Caso seja detectado algum caractere do outro Arduino,
  // esse dado é lido e guardado em uma variável local c,
  // que é verificada e, de acordo com o seu valor,
  // as coordenadas x e y sofrem alterações.
  if(Serial.available() > 0){
    char c;
    c = Serial.read();
    if(c == 'b'){
      y+=5;
    }
    else if(c == 'e'){
      x-=5;
    }
    else if(c == 'c'){
      y-=5;
    }
    else if(c == 'd'){
      x+=5;
    }
    // Atualiza-se o display com a nova posição do personagem.
    display.clearDisplay();
    display.display();
    display.setCursor(x,y);
    display.write(2);
    display.display();
    delay(300);
  }
}

É importante passar o código para as placas sem que elas estejam conectadas entre si. Então retire rapidamente as conexões UART e o GND, e faça o envio do código para cada um dos Arduinos. Feito isso, reconecte os fios.

Agora basta conectar os dois Arduinos em portas USB diferentes do seu computador e tudo estará pronto para testar o seu projeto. Caso queira saber como funcionam os códigos de utilizados em cada Arduino, acesse o novo curso da FilipeFlop sobre programação com Arduino, que irá te dar as ferramentas necessárias para entender esse tipo de programa e fazer os seus próprios.

Funcionamento do projeto com 2 Arduinos
Funcionamento do projeto com 2 Arduinos

E aí, maker! Gostou? Chegamos ao fim do nosso artigo e espero que você tenha gostado e entendido como utilizar a comunicação UART. Quaisquer dúvidas, sugestões, elogios, críticas que tiver, não hesite em mandar aqui nos comentários abaixo.

E não esqueça de nos seguir no Instagram, para ficar por dentro das novidades do blog 🙂

Faça um bom proveito de seus novos conhecimentos e até mais!

Faça seu comentário

Acesse sua conta e participe