MCO018703 2018 1 AULA09: mudanças entre as edições

De MediaWiki do Campus São José
Ir para navegação Ir para pesquisar
Douglas (discussão | contribs)
Douglas (discussão | contribs)
 
(9 revisões intermediárias pelo mesmo usuário não estão sendo mostradas)
Linha 1: Linha 1:
=Plataforma Arduíno=
=Introdução=


(Extraído da apostila [https://wiki.ifsc.edu.br/mediawiki/images/2/22/ApostilaArduino1.pdf Curso de Arduíno], de Álvaro Justen e do curso http://www.oficinaderobotica.ufsc.br Programação Básica em Arduíno], UFSC)
Assim como a IDE, que já vem com diversas funções pré-definidas, o Arduino possui outras '''bibliotecas''' para controle
de servomotores, displays LCD, geração de áudio, recepção de sinais de sensores e outros dispositivos (como teclado PS/2), dentre muitas outras funções.


*Arduino 1 é um projeto que engloba software e hardware e tem como objetivo fornecer uma plataforma fácil para prototipação de projetos interativos, utilizando um microcontrolador.
E quem pensa que essa estensibilidade toda se restringe ao software está muito enganado: o Arduino possui o que chamamos de ''shields'', que são placas que se acoplam à placa original, agregando funcionalidades à mesma.
*O projeto do Arduino teve início em 2005 na cidade de Ivrea, Itália.
*O Arduino é composto por uma placa com microcontrolador Atmel AVR e um ambiente de programação baseado em [http://wiring.org.co/reference/ Wiring] e C++.
*Tanto o hardware como o ambiente de programação do Arduino são [https://pt.wikipedia.org/wiki/Hardware_livre livres], ou seja, qualquer pessoa pode modificá-los e reproduzi-los.  


Existem ''shields'' dos mais variados tipos, para as mais diversas funções: [http://playground.arduino.cc/Main/SimilarBoards Lista oficial].


O Arduino também é conhecido como [https://computacaofisicabr.wordpress.com/o-que-e-computacao-fisica/ plataforma de computação física].  
Alguns servem como entrada, outros como saída, e ainda outros como entrada e saída.  


'''PLATAFORMAS DE COMPUTAÇÃO FÍSICA:''' são sistemas digitais ligados a
Com os shields conseguimos, por exemplo, fazer o Arduino se comunicar numa rede Ethernet, ou ainda transmitir dados para qualquer dispositivo via Bluetooth, Wi-Fi ou Zigbee.  
sensores e atuadores, que permitem construir sistemas que percebam a realidade e respondem com ações físicas.
O Arduíno é baseado em uma placa microcontrolada, com acessos de Entrada/Saída (I/O), que permite a criação de sistemas embarcados para aplicações industriais, comerciais, amadoras, profissionais, dos mais variados tipos.  


Existem [http://blog.fazedores.com/conheca-os-shields-e-incremente-seu-arduino-com-eles/ ''shields''] com circuitos integrados prontos para controlarmos motores, sem que precisemos nos preocupar com complicações eletrônicas envolvidas, outros possuem leitor de cartão SD, acelerômetro, GPS e diversos outros sensores que podem gerar dados importantes para o software que está rodando no microcontrolador.


Existem inúmeros modelos de Arduínos, como veremos na sequência, mas existem alguns mais populares, como o antigo Duemilanove (2009, em italiano) e o Uno, muito utilizado atualmente.


[[imagem:Fig007_MCO18703.jpg|445px|center]]
<center>
Figura 1 - Arduíno com Shield acoplada.
</center>


[[imagem: Fig001_MCO018703.jpg|center]]


Existem também outros ''shields'' mais elaborados, que são sistemas completos.


A principal diferença entre um Arduino e um computador convencional é que, além ter menor porte (tanto
[[imagem:Fig008_MCO18703.png|500px|center]]
no tamanho quanto no poder de processamento), o Arduino utiliza dispositivos diferentes para entrada e saída
<center>
em geral.
Figura 2 - Shields são placas para acoplar ao Arduíno visando expandir suas funcionalidades.
</center>


Por exemplo: em um PC utilizamos teclado e mouse como dispositivos de entrada e monitores e
[[imagem:Fig010_MCO18703.png|500px|center]]
impressoras como dispositivos de saída; já em projetos com o Arduino os dispositivos de entrada e saída são
<center>
circuitos elétricos/eletrônicos.
Figura 3 - Várias Shields permitem a sobreposição de outros Shiels.
</center>




Como a interface do Arduino com outros dispositivos está mais perto do meio físico que a de um PC,
Um deles, por exemplo, cria uma plataforma para desenvolvimento de jogos no Arduino: o '''Video Game Shield10''', que possui uma saída RCA
podemos ler dados de sensores (temperatura, luz, pressão etc.) e controlar outros circuitos (lâmpadas, motores,
e duas entradas para controles Numchuck do Nintendo Wii.  
eletrodomésticos etc.), dentre outras coisas que não conseguiríamos diretamente com um PC.  


A grande diferença com relação ao uso desses dispositivos, no caso do Arduino, é que, na maior parte das vezes, nós mesmos
Além do hardware, existe uma biblioteca para ser utilizada em conjunto, que já possui várias funções pré-programadas para fazermos desenhos na televisão e capturar os dados dos movimentos nos controles.
construímos os circuitos que são utilizados, ou seja, não estamos limitados apenas a produtos existentes no
mercado: o limite é dado por nosso conhecimento e criatividade!
O melhor de tudo nesse projeto é que seu software, hardware e documentação so abertos. O software é livre
(GNU GPL2), o hardware é totalmente aberto, especificado (basta entrar no site e baixar os esquemas) e a documentação
está disponível em Creative Commons3, os usuários podem colaborar (seja escrevendo documentação, seja
traduzindo) através da wiki!


=Leitura de portas digitais=


==Modelos de Arduíno==
Utilizamos as portas digitais quando precisamos trabalhar com valores bem definidos de tensão.
Apesar de nem sempre ser verdade, geralmente trabalhamos com valores digitais binários, ou seja, projetamos sistemas que
utilizam apenas dois valores bem definidos de tensão.


*Arduino UNO
Existem sistemas ternários, quaternários, mas focaremos no binário, já que é esse o utilizado pelo Arduino.
*Arduino Leonardo
*Arduino Due
*Arduino Esplora
*Arduino Mega
*Arduino Mega ADK
*Arduino Ethernet
*Arduino Mini
*Arduino LilyPad
*Arduino Micro
*Arduino Nano
*Arduino ProMini
*Arduino Pro
*Arduino Fio


[[imagem: modelos2.jpg|center]]
Como o sistema é binário, temos que ter apenas duas tensões. São elas:  
* 0V e
* 5V


===Quadro Comparativo===
Dessa forma, as portas digitais do Arduino podem trabalhar apenas com essas duas tensões, e o software que desenvolveremos poderá
(arduino.org)
requisitar ao microcontrolador do Arduino que leia o valor de uma determinada porta (e obterá 0V ou 5V, como resposta).


[[imagem: quadro.jpg|center]]
O Arduino Uno possui 14 portas digitais que estão destacadas na figura a seguir:


===Arduino UNO:===
[[imagem:Fig011_MCO18703.png|500px|center]]
<center>
Figura 4 - Em destaque a localização das portas digitais no Arduíno Duemilanove.
</center>


Talvez o modelo mais popular atualmente seja o Uno:


[[imagem: uno2.jpg|center]]
Apesar de ser possível, não é recomendável utilizar as portas 0 e 1 pois elas estão diretamente ligadas ao
sistema de comunicação do Arduino (pinos RX e TX - recepção e transmissão, respectivamente) e, por isso,
seu uso pode conflitar com o ''upload'' do software.  


*Microcontrolador: '''ATmega328 '''
Caso queira utilizá-las, certifique-se de desconectar quaisquer circuitos conectados a ela no momento do ''upload''.
*Tensão de operação: '''5V '''
*Tensão recomendada (entrada): '''7-12V '''
*Limite da tensão de entrada: '''6-20V '''
*Pinos digitais: '''14''' (seis pinos com saída PWM)
*Entrada analógica: '''6 pinos'''
*Corrente contínua por pino de entrada e saída: '''40 mA'''
*Corrente para o pino de 3.3 V: '''50 mA'''
*Quantidade de memória FLASH: '''32 KB''' (ATmega328) onde 0.5 KB usado para o bootloader
*Quantidade de memória SRAM: '''2 KB''' (ATmega328)
*Quantidade de memória EEPROM: '''1 KB''' (ATmega328)
*Velocidade de clock: '''16 MHz'''


====Alimentação ====
Utilizaremos as funções ''digitalRead'' e ''digitalWrite'' para ler e escrever, respectivamente, nas portas digitais.
* O Arduino UNO pode ser alimentado pela porta USB ou por uma fonte externa DC.
*A recomendação é que a fonte externa seja de 7 V a 12 V e pode ser ligada diretamente no conector de fonte ou nos pinos Vin e Gnd.


==Instalação do software==


Para criar um projeto com o Arduino, basta comprar uma placa Arduino (utilizaremos o Arduino Uno, como exemplo) (que custa em torno de US$30 no exterior e por volta de R$100 no Brasil), fazer download da interface integrada de desenvolvimento (IDE) e ligar a placa à porta USB do PC.
A função ''digitalWrite'' já foi exemplificada em nosso exemplo '''Blink'''.  


Como qualquer computador/microcontrolador, o Arduino precisa de um software para executar comandos. Esse software será desenvolvido na Arduino IDE em nosso PC, utilizando a linguagem C/C++.
Para exemplificar a função ''digitalRead'' utilizaremos um botão, tipo ''push-button'', como no diagrama a seguir:


Após escrever o código, o compilaremos e então faremos o envio da versão compilada para a memória ‘’flash’’ do Arduino, através da porta USB.
[[imagem:Fig012_MCO18703.png|500px|center]]
<center>
Figura 5 - Circuito de entrada digital com ''push-button''.
</center>


A partir do momento que o software é gravado no Arduino não precisamos mais do PC: o Arduino conseguirá executar o software independentemente, modo ‘’standalone’’, desde que seja ligado a uma fonte de energia.
O botão ''push-button'' também é chamado ''micro switch'' e tem o seguinte funcionamento:
Antes de iniciar nosso projeto precisamos então instalar a IDE.


O ambiente de desenvolvimento do Arduino (IDE) é gratuito e pode ser baixado no seguinte endereço: [[http://www.arduino.org/software#ide Arduino.org/software#ide]]
[[imagem:Fig013_MCO18703.png|500px|center]]
<center>
Figura 6 - ''Push-button'' de pólo simples com 2 ou 4 pinos de contato.
</center>


Vamos lá:
Assista o vídeo sobre o uso do botão '''push-button''' para acionar led:  
* Ubuntu GNU/Linux 10.10: Basta executar em um terminal:
: sudo aptitude install arduino
ou procurar pelo pacote \arduino no Synaptic (menu Sistema!Administração!Gerenciador de pacotes Synaptic).
* Ubuntu GNU/Linux (anterior a 10.10): Consulte a página de instalação do Arduino em Ubuntu.
* Outras distribuições GNU/Linux: Consulte a página de instalação em outras distribuições GNU/Linux.
* Microsoft Windows: Basta baixar o arquivo de instalação e clicar duas vezes no mesmo. Consulte a página de instalação para as variadas versões do Microsoft Windows.
* Apple Mac OS X: Consulte a página de instalação para o Mac OS X.


Após a instalação, abra a IDE. A seguinte tela será mostrada:
<center>{{#ev:youtube|Xf2L7VfNa9Y#!}} </center>
[[imagem: IDEarduino.jpg|center]]


As seguintes configurações são necessárias:


[[imagem: IDEinicio.jpg|center]]
==Circuito do ''push-button''==


Chamamos um código feito para Arduino de sketch e o salvamos em um arquivo com a extensão .pde.
Montado o circuito acima, vamos programar o Arduino com o seguinte código:


Com nosso sketch pronto, bastará conectar o Arduino na porta USB e clicar no botão ''upload'' (segundo, da direita para a esquerda { destacado na figura acima).
<syntaxhighlight lang=c>
#define BOTAO 6
#define LED 13
void setup() {
    pinMode(LED, OUTPUT);
    pinMode(BOTAO, INPUT); // pode fazer uso do resistor interno de PULLUP*
}
void loop() {
    if (digitalRead(BOTAO) == HIGH)
      digitalWrite(LED, LOW);
   
    else
      digitalWrite(LED, HIGH);
   
}
</syntaxhighlight>


Após o processo, será vista a mensagem '''Done uploading''' na IDE e então o sketch estará rodando no Arduino, ou seja, o LED acenderá e apagará, de 1 em 1 segundo. Vamos agora à explicação do processo:
[* pinMode(BOTAO, INPUT_PULLUP);]


==IDE Arduino==
A função ''digitalRead'' nos retorna o valor correspondente à tensão que está na porta que passamos entre
parenteses.


Em nosso exemplo, utilizamos a porta BOTAO (que na verdade é uma constante, definida através da diretiva #define), cujo valor é 6.


[[imagem: arduino.jpg|center]]
O valor retornado é uma constante, mapeado da seguinte forma:
Utiliza uma biblioteca de funções que simplifica a sua programação, por meio de uma sintaxe similar a das linguagens C e C++ ([http://wiring.org.co/reference/ ''Wiring'']).
* HIGH, caso a tensão na porta seja 5V
* LOW, caso a tensão na porta seja 0V




As principais funcionalidades do IDE do Arduino são:
O que o programa faz, então, é apagar o LED caso o botão esteja pressionado e acendê-lo, caso não esteja.
*Escrever o código do programa  
*Salvar o código do programa
*Compilar um programa
*Transportar o código compilado para a placa do Arduino (menu '''Upload''')
*Permitir comunicação serial com o PC


===Funções===
Um circuito alternativo, mais indicado, por não deixar a entrada digital "flutuando", quando a chave está aberta, é o abaixo:


As duas principais funções de um código Arduíno, isto é, de um programa desenvolvido para o Arduino são:  
[[imagem:Fig014_MCO18703.png|500px|center]]
<center>
Figura 6 - Realização do circuito ''push-button'' com entrada digital fixa em GND ou 5V.
</center>


*''setup()'': onde devem ser definidas algumas configurações iniciais do programa. Executa uma única vez, no início.
Neste caso, o pino 7 está ligado a um resistor de ''pull-up'', se a chave estiver aberta (neste caso, fica com nível lógico alto), ou aterrado (nível lógico baixo), quando a chave fecha:
*''loop()'': função principal do programa. Fica executando indefinidamente.


Todo programa para o Arduino deve ter estas duas funções!
[[imagem:Fig015_MCO18703.png|400px|center]]
<center>
Figura 7 - Diagrama do circuito ''push-button'' no pino digital fixa em GND ou 5V.
</center>


[[imagem: funcs1.jpg|center]]
O programa ficaria:


<syntaxhighlight lang=c>
#define BOTAO 7
#define LED 13
void setup() {
    pinMode(LED, OUTPUT);
    pinMode(BOTAO, INPUT);
}
void loop() {
    if (digitalRead(BOTAO) == HIGH)
      digitalWrite(LED, LOW);
   
    else
      digitalWrite(LED, HIGH);
}
</syntaxhighlight>


====Exemplo 1: acionando o led da placa (pino digital 13)====
E, neste caso, o LED permanece apagado, se a chave estiver aberta;


Começaremos com o exemplo clássico '''Blink''', que já vem como exemplo, no aplicativo.  
[[imagem:Fig016_MCO18703.png|400px|center]]
<center>
Figura 8 - Chave S<sub>1</sub> desligada.
</center>


Para encontrar o exemplo clique em '''File ! Examples ! Digital ! Blink'''.
e acende, quando o botão for pressionado.


O programa tem como objetivo acender e apagar o LED de um em um segundo. Para compilar
[[imagem:Fig017_MCO18703.png|400px|center]]
este exemplo não é necessário de nenhuma outra infraestrutura, ou ''hardware'', que não o próprio Arduino.
<center>
Figura 9 - Chave S<sub>1</sub> pressionada.
</center>


Primeiramente, vamos criar uma variável chamada '''ledPin''' para endereçar o pino de saída, onde o LED da placa já está conectado (variável do tipo inteiro):
===Pushbutton como interruptor liga/desliga===


int ledPin = 13;
Criar um circuito para atribuir duas funções em um único botão (pushbutton). O botão servirá como um interruptor para ligar e desligar um componente eletrônico. Neste exemplo vamos ligar e desligar um led utilizando o pushbutton como interruptor.


Assim quando nos referirmos à variável ledPin, estaremos nos referindo ao pino 13.
<syntaxhighlight lang=c>
const int buttonPin = 6;
const int ledPin = 13;


Este tipo de instrução não é obrigatória, mas é uma das boas práticas de programação e organização de código!
int estado = 0; // variável para leitura do pushbutton
int guarda_estado = LOW; // variável para armazenar valores do pushbutton
 
void setup() {
    pinMode(ledPin, OUTPUT);
    pinMode(buttonPin, INPUT); // resistor de pullup -> pinMode(buttonPin, INPUT_PULLUP);
}
 
void loop(){
    estado = digitalRead(buttonPin);
    if (estado == HIGH) {    // para pullup (estado==LOW)
        guarda_estado = !guarda_estado;  // inverte valor da variável variable_buttonEstado
        delay(500); //esperera o tempo de 500ms para evitar que haja várias vezes alterações
    }
    if (guarda_estado == HIGH) {
        digitalWrite(ledPin, HIGH);
    }
    else {
        digitalWrite(ledPin, LOW);
    }
}
</syntaxhighlight>


==Exercícios==


O seguinte passo é classificar o ledPin como pino de '''SAÍDA''', porque os pinos são bidirecionais.
:1. Altere o programa Button para trocar o estado do LED quando o botão é pressionado.
:2. Explique e implemente o código abaixo:


Isto é feito da seguinte maneira:
<syntaxhighlight lang=c>
#define BOTAO 6
#define LED 13
void setup() {
  pinMode(LED, OUTPUT);
  pinMode(BOTAO, INPUT);
}


void setup() {
void loop() {
   pinMode(ledPin, OUTPUT);
   digitalWrite(LED, !digitalRead(BOTAO));
  }
}
</syntaxhighlight>


Dica: o operador !, em linguagem C, significa negação ('''not''') e tem como finalidade complementar a expressão que segue à sua direita.


A função ''pinMode()'' tem como primeiro parâmetro o número do pino e como segundo parâmetro, se
=Referências=
ele é pino de entrada ou saída.
 
Agora começaremos a escrever o processamento.
 
O programa rodará em um ''loop eterno'', pois não deverá haver interrupções (ocorrências ou interferências que mudem o estado).
 
Dentro do loop terá uma função que fará o LED ficar aceso por 1 segundo e depois apagado, por mais um segundo, e assim, sucessivamente.
 
Escreva da seguinte maneira:
 
void loop() {
    digitalWrite(ledPin, HIGH);
    delay(1000);
    digitalWrite(ledPin, LOW);
    delay(1000);
  }
 
A função ''delay(x)'' pára a execução do código durante ''x'' milissegundos (ms). Por isto temos que utilizar o argumento 1000, para setar os atrasos em 1 segundo (=1000 ms).
 
O código completo poderia ser:
 
[[imagem: funcs2.jpg|center]]
 
A função ''digitalWrite()'' '''escreve''' uma informação digital (nível lógico), ou seja, 0 (LOW) ou 1 (HIGH) em uma das saídas digitais.
Seu primeiro parâmetro é o pino de saída, que no caso é o '''ledPin''' (pino 13).
O segundo parâmetro é o estado a ser atribuído ao pino, HIGH ou LOW.
 
Quando uma porta digital está em estado baixo (LOW), ela estará em 0V; já quando está em estado alto (HIGH), estará com 5 V.
 
 
 
Antes de fazer o ''upload'' do programa (carregar o código pra memória FLASH do Arduíno), primeiro deve-se escolher a porta USB em que o Arduino se encontra (conectado ao PC).
 
Para isso vá em '''Tools ! Serial Port ! porta''', para setar onde porta é o nome da porta onde estão ligados
o Arduino (/dev/ttyUSB*, no caso de GNU/Linux, COM* em Windows).
 
Para saber em qual porta o Arduino se encontra, faça por tentativa e erro, logo escolha um e tente rodar, caso não
rode, é o outro.


Outro passo que deve-se fazer é escolher o modelo da placa, para isso vá em: '''Tools ! Board''' e o modelo da sua placa.  
[1] https://www.sparkfun.com/categories/240?page=all


Agora sim para fazer o upload, clique em ''Upload'', como mostra a figura abaixo:
[2] https://wiki.ifsc.edu.br/mediawiki/index.php/AULA_3_-_Microcontroladores_-_T%C3%A9cnico
 
[[imagem: upload.jpg|center]]
 
Deve-se ressaltar que a IDE Arduino inclui automaticamente todas as bibliotecas que utilizamos.
 
Se você está acostumado com C/C++, note que não precisamos digitar as diretivas ''include'' para arquivos como o
''stdlib.h'', por exemplo.
 
Tudo é feito de forma automática para facilitar o desenvolvimento do projeto!
 
 
Como o Arduino já vem com um LED internamente conectado á porta 13, não precisaremos de circuitos
externos para que esse projeto funcione, ou seja, bastará fazer ''upload'' daquele código e já teremos o resultado
esperado:
 
[[imagem: blink.jpg|center]]
 
====Exercícios:====
#Altere o código para que o led da placa fique 2 segundos apagado e 3 segundos aceso.
#Altere o código para que o led da placa fique 1 segundo aceso, 2 segundos apagado, mais meio segundo aceso e 300 ms apagado.
#Porque a função ''delay()'' é necessária?
#Porque foi necessário utilizar-se o pino digital 13?
 
===Outras funções===
 
====Digital I/O====
pinMode() digitalWrite() digitalRead()
 
====Analógico I/O====
analogReference() analogRead() analogWrite() - PWM
 
====Avançado I/O====
tone() noTone() shiftOut() pulseIn()
 
====Tempo====
  millis() micros() delay() delayMicroseconds()
 
====Matemática====
min() max() abs() constrain() map() pow() ***só do C/C++ sqrt() ***só do C/C++
 
====Trigonométrica====
sin() ***só do C/C++ cos() ***só do C/C++ tan() ***só do C/C++
 
====Números aleatórios====
randomSeed() random()
 
====bits e Bytes====
lowByte() highByte() bitRead() bitWrite() bitSet() bitClear() bit()
 
====Interrupções externas====
attachInterrupt() detachInterrupt()
 
====Interrupções====
  interrupts() noInterrupts()
 
====Comunicação Serial====
 
Serial.
begin()  read()  write()  print()  println() e available()
 
=Referências=
[1] [http://www.arduino.cc/ ''Site'' oficial Projeto Arduino]


[2] [http://www.CursoDeArduino.com.br/apostila Baixar apostila de Álvaro Justen]
[3] http://squids.com.br/arduino/index.php/projetos-arduino/projetos-basicos/123-projeto-04-pushbutton


[3] [http://oficinaderobotica.ufsc.br/files/2013/04/Programação-em-Arduino-Módulo-Básico.pdf Curso de programação básica para Arduíno]




Linha 293: Linha 238:


-----
-----
[[Imagem:icone_voltar.png|link=MCO018703_2018_1_AULA01]]
[[Imagem:icone_voltar.png|link=MCO018703_2018_1_AULA08]]
[[Imagem:icone_menu.png|link=MCO018703_2018_1#Aulas]]
[[Imagem:icone_menu.png|link=MCO018703_2018_1#Aulas]]
[[Imagem:icone_prox.png|link=MCO018703_2018_1_AULA03]]
[[Imagem:icone_prox.png|link=MCO018703_2018_1_AULA10]]

Edição atual tal como às 19h15min de 26 de junho de 2018

1 Introdução

Assim como a IDE, que já vem com diversas funções pré-definidas, o Arduino possui outras bibliotecas para controle de servomotores, displays LCD, geração de áudio, recepção de sinais de sensores e outros dispositivos (como teclado PS/2), dentre muitas outras funções.

E quem pensa que essa estensibilidade toda se restringe ao software está muito enganado: o Arduino possui o que chamamos de shields, que são placas que se acoplam à placa original, agregando funcionalidades à mesma.

Existem shields dos mais variados tipos, para as mais diversas funções: Lista oficial.

Alguns servem como entrada, outros como saída, e ainda outros como entrada e saída.

Com os shields conseguimos, por exemplo, fazer o Arduino se comunicar numa rede Ethernet, ou ainda transmitir dados para qualquer dispositivo via Bluetooth, Wi-Fi ou Zigbee.

Existem shields com circuitos integrados prontos para controlarmos motores, sem que precisemos nos preocupar com complicações eletrônicas envolvidas, outros possuem leitor de cartão SD, acelerômetro, GPS e diversos outros sensores que podem gerar dados importantes para o software que está rodando no microcontrolador.


Figura 1 - Arduíno com Shield acoplada.


Existem também outros shields mais elaborados, que são sistemas completos.

Figura 2 - Shields são placas para acoplar ao Arduíno visando expandir suas funcionalidades.

Figura 3 - Várias Shields permitem a sobreposição de outros Shiels.


Um deles, por exemplo, cria uma plataforma para desenvolvimento de jogos no Arduino: o Video Game Shield10, que possui uma saída RCA e duas entradas para controles Numchuck do Nintendo Wii.

Além do hardware, existe uma biblioteca para ser utilizada em conjunto, que já possui várias funções pré-programadas para fazermos desenhos na televisão e capturar os dados dos movimentos nos controles.

2 Leitura de portas digitais

Utilizamos as portas digitais quando precisamos trabalhar com valores bem definidos de tensão. Apesar de nem sempre ser verdade, geralmente trabalhamos com valores digitais binários, ou seja, projetamos sistemas que utilizam apenas dois valores bem definidos de tensão.

Existem sistemas ternários, quaternários, mas focaremos no binário, já que é esse o utilizado pelo Arduino.

Como o sistema é binário, temos que ter apenas duas tensões. São elas:

  • 0V e
  • 5V

Dessa forma, as portas digitais do Arduino podem trabalhar apenas com essas duas tensões, e o software que desenvolveremos poderá requisitar ao microcontrolador do Arduino que leia o valor de uma determinada porta (e obterá 0V ou 5V, como resposta).

O Arduino Uno possui 14 portas digitais que estão destacadas na figura a seguir:

Figura 4 - Em destaque a localização das portas digitais no Arduíno Duemilanove.


Apesar de ser possível, não é recomendável utilizar as portas 0 e 1 pois elas estão diretamente ligadas ao sistema de comunicação do Arduino (pinos RX e TX - recepção e transmissão, respectivamente) e, por isso, seu uso pode conflitar com o upload do software.

Caso queira utilizá-las, certifique-se de desconectar quaisquer circuitos conectados a ela no momento do upload.

Utilizaremos as funções digitalRead e digitalWrite para ler e escrever, respectivamente, nas portas digitais.


A função digitalWrite já foi exemplificada em nosso exemplo Blink.

Para exemplificar a função digitalRead utilizaremos um botão, tipo push-button, como no diagrama a seguir:

Figura 5 - Circuito de entrada digital com push-button.

O botão push-button também é chamado micro switch e tem o seguinte funcionamento:

Figura 6 - Push-button de pólo simples com 2 ou 4 pinos de contato.

Assista o vídeo sobre o uso do botão push-button para acionar led:

Provided ID could not be validated.


2.1 Circuito do push-button

Montado o circuito acima, vamos programar o Arduino com o seguinte código:

#define BOTAO 6
#define LED 13
void setup() {
    pinMode(LED, OUTPUT);
    pinMode(BOTAO, INPUT); // pode fazer uso do resistor interno de PULLUP*
}
void loop() {
    if (digitalRead(BOTAO) == HIGH) 
       digitalWrite(LED, LOW);
    
    else 
       digitalWrite(LED, HIGH);
    
}

[* pinMode(BOTAO, INPUT_PULLUP);]

A função digitalRead nos retorna o valor correspondente à tensão que está na porta que passamos entre parenteses.

Em nosso exemplo, utilizamos a porta BOTAO (que na verdade é uma constante, definida através da diretiva #define), cujo valor é 6.

O valor retornado é uma constante, mapeado da seguinte forma:

  • HIGH, caso a tensão na porta seja 5V
  • LOW, caso a tensão na porta seja 0V


O que o programa faz, então, é apagar o LED caso o botão esteja pressionado e acendê-lo, caso não esteja.

Um circuito alternativo, mais indicado, por não deixar a entrada digital "flutuando", quando a chave está aberta, é o abaixo:

Figura 6 - Realização do circuito push-button com entrada digital fixa em GND ou 5V.

Neste caso, o pino 7 está ligado a um resistor de pull-up, se a chave estiver aberta (neste caso, fica com nível lógico alto), ou aterrado (nível lógico baixo), quando a chave fecha:

Figura 7 - Diagrama do circuito push-button no pino digital fixa em GND ou 5V.

O programa ficaria:

#define BOTAO 7
#define LED 13
void setup() {
    pinMode(LED, OUTPUT);
    pinMode(BOTAO, INPUT);
}
void loop() {
    if (digitalRead(BOTAO) == HIGH) 
       digitalWrite(LED, LOW);
    
    else 
       digitalWrite(LED, HIGH);
}

E, neste caso, o LED permanece apagado, se a chave estiver aberta;

Figura 8 - Chave S1 desligada.

e acende, quando o botão for pressionado.

Figura 9 - Chave S1 pressionada.

2.1.1 Pushbutton como interruptor liga/desliga

Criar um circuito para atribuir duas funções em um único botão (pushbutton). O botão servirá como um interruptor para ligar e desligar um componente eletrônico. Neste exemplo vamos ligar e desligar um led utilizando o pushbutton como interruptor.

const int buttonPin = 6; 
const int ledPin = 13; 

int estado = 0; // variável para leitura do pushbutton
int guarda_estado = LOW; // variável para armazenar valores do pushbutton
  
void setup() {
    pinMode(ledPin, OUTPUT);
    pinMode(buttonPin, INPUT); // resistor de pullup -> pinMode(buttonPin, INPUT_PULLUP);
}
  
void loop(){
    estado = digitalRead(buttonPin);
 
    if (estado == HIGH) {    // para pullup (estado==LOW)
        guarda_estado = !guarda_estado;  // inverte valor da variável variable_buttonEstado
        delay(500); //esperera o tempo de 500ms para evitar que haja várias vezes alterações
    }
    if (guarda_estado == HIGH) {
        digitalWrite(ledPin, HIGH);
    }
    else {
        digitalWrite(ledPin, LOW);
    }
}

2.2 Exercícios

1. Altere o programa Button para trocar o estado do LED quando o botão é pressionado.
2. Explique e implemente o código abaixo:
#define BOTAO 6
#define LED 13
void setup() {
   pinMode(LED, OUTPUT);
   pinMode(BOTAO, INPUT);
}

void loop() {
   digitalWrite(LED, !digitalRead(BOTAO));
}

Dica: o operador !, em linguagem C, significa negação (not) e tem como finalidade complementar a expressão que segue à sua direita.

3 Referências

[1] https://www.sparkfun.com/categories/240?page=all

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

[3] http://squids.com.br/arduino/index.php/projetos-arduino/projetos-basicos/123-projeto-04-pushbutton