Comunicação Serial no Arduino via Serial Monitor

A Comunicação Serial é um recurso amplamente utilizado no estabelecimento de comunicação entre uma placa Arduino e outros dispositivos, como módulos ZigBee e Bluetooth, shields, sensores, e até mesmo com o computador. A gravação de um código no microcontrolador do Arduino, por exemplo, é realizada via Comunicação Serial. Para que possamos ler informações via comunicação serial da placa arduino no computador, usaremos o Serial Monitor, ferramenta que pode ser encontrada na IDE Arduino.

Devido a esta enorme importância da comunicação serial, neste tutorial iremos apresentar alguns conceitos sobre esse tipo de comunicação e os procedimentos necessários para utilizar o serial monitor.

[toc]

O Serial Monitor

A IDE oficial do Arduino disponibiliza uma ferramenta chamada Serial Monitor. Essa ferramenta é uma interface gráfica que apresenta a troca de informações pela porta serial entre o Arduino e o computador. A comunicação via Serial Monitor é um recurso interessante, para monitorar o envio e no recebimento de dados, permitindo inclusive realizar testes sem a necessidade de uma interface externa.

Para acessarmos esta ferramenta, basta clicarmos no ícone localizado no canto superior direito da IDE, ou simplesmente, utilizar o atalho Ctrl+Shift+M. Também é possível abrir o Serial Monitor através do menu Tools, localizado na barra de ferramentas.

 

Em um primeiro momento, precisamos definir apenas a taxa de transmissão de dados (baud rate), que deve ser a mesma que a taxa de transmissão definida no programa que está carregado no Arduno. Além da informação da taxa, o Serial Monitor possui dois campos: um é o local onde você pode enviar dados para seu Arduino e o outro é uma área de exibição de saída de dados.

 

---

Mãos à Obra – 4 Projetos com o Serial Monitor

Aqui são apresentados 4 projetos utilizando a comunicação via Serial Monitor. Para simplificar, todos utilizam o mesmo hardware, focando no acesso e uso da ferramenta. Os projetos desenvolvidos são:

• Enviando uma mensagem para o monitor serial
• Enviando uma sequência de mensagens
• Lendo dados através do monitor serial
• Controlando o Arduino através do monitor serial

Componente necessário

• 1 x Arduino UNO Rev 3

---

Projeto 1: Enviando uma mensagem

Neste projeto vamos enviar dados através da Comunicação Serial.

Código utilizado

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    /*** Arguardando o estabelecimento da conexão ***/
  }
  Serial.print("Vida de Silicio");
}

void loop() {}

Entendendo o software

– Definindo as configurações iniciais

O primeiro passo consiste na inicialização da interface de Comunicação Serial entre a placa Arduino que estamos utilizando e o Serial Monitor. Para isto, utilizamos a função begin(), que recebe dois parâmetros: a taxa de transmissão em bits por segundo (é bastante comum 9600 em transmissões mais lentas); o segundo parâmetro é configuração de bits por transmissão, paridade e bits de parada. Deixando o segundo parâmetro em branco, a função adota o padrão. Para consultar valores possíveis para a taxa e configuração, você pode ver esse link.

Note que, por se tratarem de funções membros de uma classe, as funções disponíveis para a Comunicação Serial devem ser acessadas através do objeto global  Serial e do operador ” .” (ponto), sendo assim, para utilizar a função begin(), deve-se escrever: Serial.begin(9600).

Serial.begin(9600);

Em seguida, utilizamos a função while() com o parâmetro !Serial. Esta estrutura faz com que o programa aguarde até que a conexão serial seja estabelecida, e só então, continue a execução.

while (!Serial) {
  /*** Arguardando o estabelecimento da conexão ***/
}

– Imprimindo a informação

Por fim, utilizamos a função print() para enviar a mensagem, que será visualizada no Serial Monitor.

Serial.print("Vida de Silicio");

O resultado deve ser esse:

 

---

Projeto 2: Enviando uma sequência de mensagens

Neste projeto vamos enviar uma sequência de dados através da Comunicação Serial.

Código do projeto

Segue o código para ser utilizado no Arduino:

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    /*** Arguardando o estabelecimento da conexao ***/
  }
  Serial.println(16,DEC);
  Serial.println(16,BIN);
  Serial.println(16,OCT);
  Serial.println(16,HEX);
  Serial.println(16.2372523,2);
}

void loop() { }

– Definindo as configurações iniciais

Dentro da função setup(), inicializamos a Comunicação Serial a uma taxa de 9600 bits por segundo com begin():

Serial.begin(9600);

Como no projeto anterior, checamos o estabelecimento da conexão serial:

while (!Serial) {
  /***** Aguardando o estabelecimento da conexão *****/
}

– Imprimindo as informações

Após estabelecer a conexão serial utilizamos a função println() para enviar um dado através da porta serial e saltar para próxima linha. Outra informação interessante das funções println() e print() é que ambas podem ser utilizadas com dois parâmetros. O primeiro parâmetro é a mensagem e o segundo é a formatação.

Para imprimir, por exemplo, números inteiros, podemos utilizar o segundo parâmetro para determinar se deve ser enviado como um decimal, binário, octal ou hexadecimal:

Serial.println(16,DEC);
Serial.println(16,BIN);
Serial.println(16,OCT);
Serial.println(16,HEX);

No caso de números reais, do tipo float, esse segundo parâmetro determina o número de casas decimais:

Serial.println(16.2372523,2);

O código todo fica assim:

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    /*** Arguardando o estabelecimento da conexão ***/
  }
  Serial.println(16,DEC);
  Serial.println(16,BIN);
  Serial.println(16,OCT);
  Serial.println(16,HEX);
  Serial.println(16.2372523,2);
}

void loop() { }

E o resultado que obtemos com esse código é esse:

Se ao invés da função println(), utilizássemos a função print(), o resultado seria esse:

Repare que sem saltar linha, cada mensagem é colocada em sequência, uma após a outra.

---

Projeto 3: Lendo dados através do monitor serial

Neste projeto ensinaremos a você como fazer uma leitura de dados do Serial Monitor para o Arduino.

Código do projeto

Segue o código para leitura de dados via Serial Monitor.

char dado;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    /*** Aguardando o estabelecimento da conexão ***/
  }
}

void loop() {
  if(Serial.available()) {
    dado = Serial.read();
    Serial.print(dado);
  }
}

– Declarando a variável para armazenar a leitura

Criamos uma variável do tipo char para armazenar um caractere.

char dado;

– Definindo as configurações iniciais

Como nos projetos 1 e 2, inicializamos a comunicação serial e fazemos a checagem:

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    /***** Aguardando o estabelecimento da conexão *****/
  }
}

– Imprimindo a informação recebida

Já dentro da função loop(), temos uma função if() cujo argumento consiste em uma função chamada available(). Ela é responsável por retornar a quantidade de caracteres disponíveis para leitura na porta serial. Se não há caracteres, ela retorna zero.

Na estrutura do projeto, queremos conferir se há algum caractere para ser lido. Caso haja, o conteúdo interno da função if() será executado.

if(Serial.available() > 0) {
  /***** conteúdo da função if() *****/
}

Se houver algum caractere para ser lido, utilizamos a função read() para ler o primeiro caractere da fila na porta de entrada. Efetuamos a leitura do primeiro caractere da fila e armazenamos na variável dado.

dado = Serial.read();

Por fim, para conferir o resultado desta aplicação, utilizamos a função print() para enviar o valor recebido para o Serial Monitor.

Serial.print(dado);

A função loop() ficou assim:

void loop() {
  if(Serial.available()) {
    dado = Serial.read();
    Serial.print(dado);
  }
}

---

Projeto 4: Controlando o Arduino através do Serial Monitor

Neste projeto ensinaremos a você como proceder para controlar um led através do monitor serial.

Código do projeto

#define LED 13

char dado;

void setup() {
  pinMode(LED,OUTPUT);
  Serial.begin(9600);
  while (!Serial) {
    /*** Aguardando o estabelecimento da conexão ***/
  }
}

void loop() {
  if(Serial.available()) {
    dado = Serial.read();
    switch(dado) {
      case 'a':
        digitalWrite(LED,HIGH);
        break;
      case 'A':
        digitalWrite(LED, LOW);
        break;
    }
  }
}

– A diretiva #define

Iniciamos o código utilizando a diretiva #define para associar o nome LED ao número 13, de modo que, toda vez que chamamos “LED” no código, o compilador do Arduino interpreta como o inteiro 13. A vantagem desse recurso é que, caso seja necessária a alteração de um valor, ele só precisa ser alterado em um único lugar.

#define LED 13

– Declarando a variável para armazenar o caractere

Criamos uma variável do tipo char para armazenar um caractere.

char dado;

– Definindo as configurações iniciais

O pino 13 é configurado como saída digital.

pinMode(LED,OUTPUT);

Fazemos a inicialização e checagem da Comunicação Serial, como nos projetos anteriores.

Serial.begin(9600);
while (!Serial) { 
  /*** Aguardando o estabelecimento da conexão ***/    
}

A função setup() fica assim:

void setup() {
  pinMode(LED,OUTPUT);
  Serial.begin(9600);
  while (!Serial) {
    /***** Aguardando o estabelecimento da conexão *****/
  }
}

– Acionando o led a partir do dado recebido

Dentro da função loop(), fazemos a checagem da porta serial para a presença de caractere. Se houver, o caractere será armazenado na variável dado.

if(Serial.available() > 0) {
  dado = Serial.read();  
}

Após a leitura do primeiro caractere da fila da porta serial utilizamos a estrutura switch()/case para determinarmos qual ação deve ser tomada. Esta estrutura funciona da seguinte maneira: passamos como parâmetro da função switch() a variável que queremos comparar e, em seguida, criamos os cases, com os valores esperados da variável. Se a variável for identificada em alguns dos cases, os comandos daquele bloco serão executados. O elemento break sinaliza o final de cada case, saindo da estrutura switch().

No código, caso a variável dado seja a letra a (minúscula), o led deve ser aceso. Caso dado seja a letra A (maiúscula), apagamos o led.  

switch(dado) {
  case 'a':
    digitalWrite(LED,HIGH);
    break;
  case 'A':
    digitalWrite(LED,LOW);
    break;
}

Lembre-se que o conteúdo descrito anteriormente está localizado dentro da função loop(), portanto os procedimentos de leitura e comparação do caractere serão realizados repetidamente.

A função loop() fica assim:

void loop() 
{
  if(Serial.available()) {
    dado = Serial.read();
    switch(dado) { 
      case 'a':
        digitalWrite(LED,HIGH); 
        break; 
      case 'A': 
        digitalWrite(LED,LOW); 
        break; 
    }
  }
}

 

---

Considerações finais

Nesse conteúdo foi possível demonstrar algumas possibilidades para uso da comunicação via Serial Monitor. Esperamos que você tenha gostado, e sinta-se à vontade para deixar suas sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.