MCO018703 2018 1 AULA10

De MediaWiki do Campus São José
(dif) ← Edição anterior | Revisão atual (dif) | Versão posterior → (dif)
Ir para navegação Ir para pesquisar

Comunicação Serial

Apesar do Arduino ser gravado via porta USB, a comunicação se dá como serial padrão (USART). O ATmega328 permite comunicação serial no padrão UART TTL (5 V), que está disponível nos pinos digitais 0 (RX) e 1 (TX). Um chip FTDI FT232RL na placa encaminha esta comunicação serial através da USB e os drivers FTDI (incluído no software do Arduino) fornecem uma porta virtual para o software no computador.

O software Arduino inclui um Monitor Serial que permite que dados simples de texto sejam enviados e recebidos à placa Arduino.

Os LEDs RX e TX da placa piscam quando os dados estão sendo transferidos ao computador pelo chip FTDI e há conexão USB (mas não quando há comunicação serial pelos pinos 0 e 1).

A biblioteca SoftwareSerial permite comunicação serial por quaisquer dos pinos digitais do Uno. O ATmega328 também oferece suporte aos padrões de comunicação I2C (TWI) e SPI. Inclui uma biblioteca Wire para simplificar o uso do barramento I2C. Para usar a comunicação SPI, veja o manual do ATmega328. Assim, no Arduino existe uma parte do hardware especifica para a conversão Serial/USB.

Disso resulta a criação de uma porta COM virtual no computador para a comunicação com o Arduino.

Fig020 MCO18703.png


Como a comunicação é a serial padrão, é fácil trocar informações entre o computador e o Arduino.

Existe uma ferramenta própria na IDE do Arduino para a comunicação serial.

Fig021 MCO18703.png

A biblioteca Serial() do Wiring tem todas as funções necessárias para se implementar comunicação serial entre o Arduino e o PC.

A porta serial te permite ler e escrever facilmente dados de e para dispositivos externos.

Isto permite a duas máquinas se comunicarem através de portas seriais de 8 pinos, dos PCs, ou emulads através de um adaptador serial.

Velocidades típicas de comunicação são: 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 e 115200 BPS.

Apenas uma aplicação pode utilizar a porta serial, a cada vez.


As funções mais utilizadas são:

  • begin() Abre a porta serial para leitura ou escrita.
  • read() Retorna um número entre 0 e 255 para o próximo byte que está esperando no buffer. Retorna -1 se não há nenhum byte, embora isto possa ser evitado pelo uso da função available(), que informa se há dado disponível
  • write() Escreve um byte na porta serial.
  • print() Escreve dados (int, float, byte, char, char[], números nas bases (DEC, BIN, OCT or HEX) ou textos na porta serial.
  • println() O mesmo que a função print(), exceto que acrescenta uma linha nova ao final da chamada.
  • available() Retorna o número de bytes disponíveis.
  • peek() Investiga o próximo byte de dados no buffer da porta serial. Não o recupera do buffer. Retorna -1 se não há dado disponível.
  • flush() Descarrega o buffer da porta serial.
  • end() Fecha a porta serial.



EXEMPLO 1: Enviando texto para Monitor Serial

  void setup(){
  Serial.begin(9600);
 //Inicia a comunicação serial a 9600 bauds
  }

  void loop(){
   Serial.println("Aprendendo a programar no arduino");   
 // Envia a string "Aprendendo a programar no arduino"       
 //para a console
   }


Agora acesse o Monitor Serial, no menu do Arduino.

O resultado é uma sucessão de impressões da string “Aprendendo a programar no arduino”.

Vimos que iniciamos a comunicação serial através do comando serial.begin(9600) que colocamos dentro do setup(){} .

O valor de 9600 pode variar dependendo da sua aplicação veja mais sobre velocidade da porta serial nesse post: [Baud Rates]

O comando Serial.print(“string aqui”) que faz com que a informação seja impressa no serial monitor.

Adiante veremos outros exemplos do uso do Serial.print, mas por ora quero que reparem que todo comando que não constrói um bloco (não tem “chaves” como o setup e o loop), ou então que não e uma diretiva de pré-processador (#include, #define que veremos adiante tambem) termina com ponto e vírgula, isso indica o fim do comando.

EXEMPLO 2: Acionando o LED do Arduino, via Monitor Serial

No segundo teste, vamos acionar, acender e apagar, o led do pino 13 através de comandos de teclado do PC, na interface Serial Monitor, do Arduino.

A programação também é simples e bem interessante: 


 
 #define LED 13
 byte estebyte = 35;
 void setup() {
    pinMode(LED, OUTPUT);
    Serial.begin(9600);
 }
 void loop() {
  Serial.println(" Como enviar valores formatados: ");
  Serial.println("Formato ASCII do valor: ");
  Serial.write(estebyte);
  Serial.println(".");
  Serial.println("Formato DECIMAL:");
  Serial.print(estebyte, DEC);
  Serial.println(".");
  Serial.println("Formato HEXADECIMAL:");
  Serial.print(estebyte, HEX);
  Serial.println(".");
  Serial.println("Formato BINÁRIO:");
  Serial.print(estebyte, BIN);
  Serial.println(".");
  Serial.println("");
  Serial.println("Agora, digite 0 no Monitor para apagar o LED e 1, para acender!");
  while(true)
  { if(Serial.available() > 0)
   { estebyte = Serial.read();
     if(estebyte == '1') // Digitou 1 no Monitor Serial
     { digitalWrite(LED, HIGH);
       Serial.println(" LED ACESO!");
     }
     if(estebyte == '0') // Digitou 0 no Monitor Serial
      { digitalWrite(LED, LOW);
       Serial.println(" LED APAGADO!");
      }//end if
    }//end if
   }//end while
 }//end loop

EXEMPLO 3: Enviando estado de chave para Monitor Serial

Neste teste, o estado de uma chave externa será lido e enviado pro Monitor Serial.

1) Montagem:


Fig022 MCO18703.png

2) Código: 

int pushButton=2;

void setup()
{
   Serial.begin(9600);
   pinMode(pushButton, INPUT);
}

void loop() 
{
   int buttonState=digitalRead(pushButton);

   Serial.println(buttonState);
   delay(1);
}

3) No protoshield do laboratório:

Fig023 MCO18703.jpg

4) Quando pressiona a chave, efeito no Monitor Serial:

Fig024 MCO18703.png

EXEMPLO 4: Acionando leds externos a partir do Monitor Serial

Nosso primeiro teste de uso do Monitor Serial vai ser um circuito e programação que acionam dois leds, conforme a montagem abaixo:

Fig025 MCO18703.png

Agora, abra a IDE do Arduino e escreva/compile/carregue a seguinte programação: 

char c;
void setup()
{
    pinMode(2,OUTPUT);
    pinMode(3,OUTPUT);
    Serial.begin(9600);
}

void loop()
{
    if (Serial.available()>0)
    {
      c = Serial.read() - '0';
      Serial.flush();
      digitalWrite(c,!digitalRead(c));
    }
}


Conecte o Arduino no PC, selecione a versão do seu Arduino (UNO, Duemilanove) e porta (COMx, ttyUSBx, ttyACMx) e clique em UPLOAD. Abra o Serial Monitor e selecione 9600 no baud.

Ao digitar o número 2 no Serial Monitor, irá acender o LED conectado na porta digital 2 do Arduino, e ao digitar novamente o número 2, o LED apagará. Agora se digitar o número 3, irá acender o LED da porta digital 3 e se digitar novamente o número 3, o LED apagará.

E é isso!

Portas Analógicas

É possível ler grandezas analógicas com o Arduino, além de valores digitais.

Para isto, existem 6 Portas analógicas para ENTRADA de dados:

  • A0 (pino 14),
  • A1 (pino 15),
  • A2 (pino 16),
  • A3 (pino 17),
  • A4 (pino 18) e
  • A5 (pino 19).

Não é necessário definir-se na função setup( ) se as portas serão usadas como entrada, ou saída.

A função de leitura das portas analógicas é a analogRead( PORTA ) 

  O microcontrolador do Arduino dispõe de um Conversor Analógico-Digital (ADC) de 10 bits, o que significa capacidade de quantificar 1024 patamares de valor: 0 a 1023.

Ou seja, as tensões analógicas de entrada, que devem variar de 0 a 5 V, são quantificadas como:

  • 0 - correspondente ao valor de 0 V (GND)
  • 1 - correspondente ao valor de 1x(5 V - 0 V)/1024 = 0,0048828125 V
  • 2 - correspondente ao valor de 2x(5 V - 0 V)/1024 = 0,009765625 V
  • 3 - correspondente ao valor de 3x(5 V - 0 V)/1024 = 0,0146484375 V
  • ...
  • 1023 - correspondente ao valor de 5 V (VCC)


O programador deve saber como interpretar o número digital da conversão. Desta forma, podem ser lidos os mais variados sensores, desde que eles gerem um sinal de tensão de até 5V (limite permitido).

Fig026 MCO18703.jpg

ADC de 10 bits - 1024 patamares de quantificação.


EXEMPLO 1: Lendo dados de um potenciômetro

1) Esquemático:

Fig027 MCO18703.jpg

Para ler os valores diretamente em Volts:

2) Código fonte: 

void setup()
{ 
   Serial.begin(9600);
}

void loop()
{ 
    float valt;
    int val = analogRead(0);
  
    valt = (val*5.0)/1023;

    Serial.println(valt);
}

EXEMPLO 2: Lendo dados do potenciômetro para temporizar o LED

1) Esquemático:

Fig028 MCO18703.jpg

2) Código fonte: 

const int led=6;

void setup()
{
   pinMode(led, OUTPUT);
   Serial.begin(9600);
}

void loop()
{
   int val=analogRead(0);
   Serial.println(val);
   digitalWrite(led, HIGH);
   delay(val);
   digitalWrite(led, LOW);
   delay(val);
}

EXEMPLO 3: Lendo um NTC e utilizando a equação de Steinhart-Hart

1) Esquemático:

Fig029 MCO18703.jpg

2) Código fonte (5V): 

#include <math.h>

const int sensor = A0;

double tempCelsius(int valorNTC)
{
   double temp;

   temp = log(((10240000/valorNTC)-10000)); // para NTC de 10k
   temp = 1/(0.001129148+(0.000234125+(0.0000000876741*temp*temp))*temp);

   temp=temp-273.15; // Coonverte Kelvin para Cesius
   
   return temp;
}

void setup()
{
    Serial.begin(9600);
}

void loop()
{
   int valor=analogRead(sensor);
   double c=tempCelsius(valor);
   Serial.println(valor);
   Serial.println(c);
   delay(250);
}

Referências

[1] https://wiki.ifsc.edu.br/mediawiki/index.php/AULA_4_-_Microcontroladores_-_T%C3%A9cnico

[2] https://wiki.ifsc.edu.br/mediawiki/index.php/AULA_5_-_Microcontroladores_-_T%C3%A9cnico



Icone voltar.png Icone menu.png Icone prox.png

Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=MCO018703_2018_1_AULA10&oldid=146938”