![5.2 Exemplo 2 - Acionamento de LEDs externos
Neste exemplo, exploraremos melhor as sa´ıdas digitais. Neste exemplo ser˜ao necess´arios 10
LEDs para sua execu¸c˜ao. Os LEDs ascender˜ao em sequˆencia e ficar˜ao acesos por 1 segundo,
at´e que o ´ultimo apagar´a e todos os outros em sequˆencia apagar˜ao. Para a confec¸c˜ao do projeto
ligue o positivo dos LEDs nos pinos digitais de 2 ´e 11 e a outra ponta em um protoboard, no lado
negativo dos LEDs ligue resistores de 150 Ω, em s´erie, e a outra ponta de todos os resistores no
terra do Arduino, GND na placa. Assim como na Figura 5.2.
Figura 5.2: Circuito Exemplo 2.
As primeiras linhas de comando s˜ao para declara¸c˜ao de vari´aveis, iremos precisar de uma
vari´avel constante e inteira de valor 10, em nosso caso chamamos de LEDCount. Outra vari´avel
necess´aria ´e um vetor com 10 posi¸c˜oes, enumerados de 2 ´e 11, que s˜ao os n´umeros dos pinos de
sa´ıda digital que ser˜ao utilizados que tamb´em possuem valores inteiros, chamamos o vetor de
LEDPin. A seguir vem a declara¸c˜ao a ser feita:
const int LEDCount = 10;
int LEDPins[] = { 2, 3, 4, 5, 6, 7,8,9,10,11 };
Agora com as vari´aveis declaradas vamos definir o vetor LEDPins como pinos de sa´ıda ,
para isso utilizaremos um loop, da seguinte maneira:
void setup() {
for (int thisLED = 0; thisLED < LEDCount; thisLED++) {
pinMode(LEDPins[thisLED], OUTPUT);
}
}
Na primeira posi¸c˜ao do for declaramos uma vari´avel que inicia em 0. Na segunda posi¸c˜ao
damos a condi¸c˜ao para o for, e na terceira a cada vez que ´e verificada a condi¸c˜ao do for,
com execu¸c˜ao da primeira, ´e acrescido 1 ao valor de thisLED, que ´e a vari´avel que utilizaremos
18](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-19-320.jpg)
![para chamar as determinadas posi¸c˜oes do vetor LEDPins. A fun¸c˜ao pinMode(), como vista no
exemplo anterior, est´a declarando que o vetor LEDPins ´e um vetor de sa´ıda de dados. Agora
ser´a iniciado um loop, que far´a com que o programa sempre rode, dentro dele ter´a um for que
acender´a todos os LEDs sequencialmente, com um intervalo de 1 segundo (1000 ms) entre cada
LED. O corpo do programa fica da seguinte maneira:
void loop() {
for (int thisLED = 0; thisLED < LEDCount; thisLED++) {
digitalWrite(LEDPins[thisLED], HIGH);
delay(1000);
}
delay(1000);
Perceba que o for ´e da mesma maneira que o ´ultimo, pois a id´eia ´e sempre se referir `as
posi¸c˜oes do vetor, a diferen¸ca aqui ´e que para cada posi¸c˜ao estamos acendendo um LED, usando
a fun¸c˜ao digitalWrite(). A fun¸c˜ao delay() foi utilizada para que seja mais f´acil de visualizar
que cada LED acende de cada vez, e que ap´os todos os LEDs acenderem, todos ficam acesos
por mais um segundo.
Agora ser´a feito o mesmo, mas para apagar os LEDs, como mostra a seguir:
for (int thisLED = 9; thisLED >= 0; thisLED--) {
digitalWrite(LEDPins[thisLED], LOW);
delay(1000);
}
delay(1000);
}
A vari´avel thisLED, utilizada apenas no for, come¸ca com valor 9 e ´e decrescida de 1 at´e
que chegue em 0, logo os LEDs apagar´a o do ´ultimo a acender para o primeiro, e permanecer´a
apagado por 1 segundo.
Este foi o segundo exemplo, perceba que ´e poss´ıvel modific´a-lo com o que j´a foi aprendido,
fazendo com que ele apague na mesma ordem que acende, ou fazendo qualquer outra mudan¸ca
desejada.
19](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-20-320.jpg)
![Para que tenhamos um sorteio bem variado, faremos um vetor de 0 a 100. Criaremos uma
vari´avel para que contemos em qual rodada estamos, para que facilite a intera¸c˜ao tons-LEDs.
Al´em disso, criaremos uma vari´avel para indicar o passo atual da sequˆencia.
int tons[4] = { NOTE_A4, NOTE_G4, NOTE_D4 ,NOTE_A5};
int sequencia[100] = {};
int rodada_atual = 0;
int passo_atual_na_sequencia = 0;
Criaremos as vari´aveis que receber˜ao quais portas os LEDs, bot˜oes e autofalante est˜ao
ligados. Al´em de mais duas vari´aveis de controle, a botao pres- sionado para indicar se
algum bot˜ao fora pressionado e a perdeu_o_jogo para terminar a partida.
int pinoAudio = 7;
int pinosLEDs[4] = { 8, 9,10,11 };
int pinosBotoes[4] = {2,3,4,5};
int botao_pressionado = 0;
int perdeu_o_jogo = false;
Na fun¸c˜ao void setup() iremos definir quais pinos ser˜ao de entrada e de sa´ıda, al´em de
usarmos a fun¸c˜ao randˆomica randomSeed, que gera um valor vari´avel entre 0 e 1023. Ela ser´a
importante para que o jogo n˜ao fique repetitivo.
void setup() {
for (int i = 0; i <= 3; i++) {
pinMode(pinosLEDs[i], OUTPUT);
}
for (int i = 0; i <= 3; i++) {
pinMode(pinosBotoes[i], INPUT);
}
pinMode(pinoAudio, OUTPUT);
randomSeed(analogRead(0));
}
Note que, como definimos os bot˜oes e LEDs como vetores, na fun¸c˜ao void setup() utili-
zaremos a estrutura de controle for para atribuir valores iniciais para tais vetores.
Agora come¸caremos a montar a estrutura do jogo propriamente dita, inicializando o loop.
void loop() {
if (perdeu_o_jogo) {
int sequencia[100] = {};
29](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-30-320.jpg)
![rodada_atual = 0;
passo_atual_na_sequencia = 0;
perdeu_o_jogo = false;
}
Primeiramente, faremos uma condi¸c˜ao onde zeramos todas as vari´aveis caso o jogador perca
a partida. Para a condi¸c˜ao ser verdadeira, como explicado acima, usaremos a vari´avel booleana
perdeu_o_jogo. Onde ela assumir´a o valor true caso o usu´ario seja derrotado pela m´aquina.
Como nesse exemplo n˜ao inclu´ımos um display, para informar que come¸car´a o jogo, vamos
colocar um som de in´ıcio para anunciar que ´e a primeira rodada.
if (rodada_atual == 0) {
tocarSomDeInicio();
delay(500);
}
Depois disso, devemos inicializar a pr´oxima rodada, reproduzir a sequˆencia e aguardar o
jogador clicar os bot˜oes. H´a um atraso de 1 segundo entre cada jogada.
proximaRodada();
reproduzirsequencia();
aguardarJogador();
delay(1000);
}
OBS.: Note que aqui termina nossa fun¸c˜ao Void loop().
At´e aqui, criamos a primeira rodada, onde apenas uma luz foi acesa. Em seguida, vamos
adicionar mais um luz para cada rodada com a fun¸c˜ao void proximaRodada().
Sorteamos um dos LEDs a serem acesos, atrav´es da fun¸c˜ao random(), e completamos a
fun¸c˜ao void atribuindo ao nosso vetor sequˆencia qual foi o valor sorteado.
void proximaRodada() {
int numero_sorteado = random(0, 3);
sequencia[rodada_atual++] = numero_sorteado;
}
Anteriormente, criamos a sequˆencia. Agora, iremos reproduz´ı-la. Usaremos a estrutura de
repeti¸c˜ao for para que os pinos de sa´ıda adequados sejam acionados.
void reproduzirsequencia() {
for (int i = 0; i < rodada_atual; i++) {
tone(pinoAudio, tons[sequencia[i]]);
digitalWrite(pinosLEDs[sequencia[i]], HIGH);
delay(500);
noTone(pinoAudio);
digitalWrite(pinosLEDs[sequencia[i]], LOW);
delay(100);
}
noTone(pinoAudio);
}
30](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-31-320.jpg)
![Neste ponto, iremos verificar se o jogador acertou ou errou a sequˆencia. Caso tenha errado,
o programa para e voltamos para o in´ıcio. Caso contr´ario, o programa continua, zerando o
passo da sequˆencia.
void aguardarJogador() {
for (int i = 0; i < rodada_atual; i++) {
aguardarJogada();
verificarJogada();
if (perdeu_o_jogo) {
break;
}
passo_atual_na_sequencia++;
}
passo_atual_na_sequencia = 0;
}
Neste trecho de c´odigo temos o complemento do anterior, onde aqui damos o comando para
que os ´audios e os LEDs sejam acionados quando requeridos. ´E importante destacar que quando
atribu´ımos `a vari´avel botao_pressionado o valor de i, usamos esse valor para que o programa
associe corretamente qual LED ser´a aceso e qual som dever´a ser reproduzido.
void aguardarJogada() {
boolean jogada_efetuada = false;
while (!jogada_efetuada) {
for (int i = 0; i <= 3; i++) {
if (digitalRead(pinosBotoes[i]) == HIGH) {
// Dizendo qual foi o botao pressionado.
botao_pressionado = i;
tone(pinoAudio, tons[i]);
digitalWrite(pinosLEDs[i], HIGH);
delay(300);
digitalWrite(pinosLEDs[i], LOW);
noTone(pinoAudio);
jogada_efetuada = true;
}
}
delay(10);
}
}
Por ´ultimo, temos a fun¸c˜ao void verificarJogada(), que cria a condi¸c˜ao para que, caso
o jogador perca, todos os LEDs pisquem rapidamente, indicando isso.
void verificarJogada() {
if (sequencia[passo_atual_na_sequencia] != botao_pressionado) {
31](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-32-320.jpg)
![for (int i = 0; i <= 3; i++) {
tone(pinoAudio, tons[i]);
digitalWrite(pinosLEDs[i], HIGH);
delay(200);
digitalWrite(pinosLEDs[i], LOW);
noTone(pinoAudio);
}
tone(pinoAudio, tons[2]);
for (int i = 0; i <= 3; i++) {
digitalWrite(pinosLEDs[0], HIGH);
digitalWrite(pinosLEDs[1], HIGH);
digitalWrite(pinosLEDs[2], HIGH);
digitalWrite(pinosLEDs[3], HIGH);
delay(100);
digitalWrite(pinosLEDs[0], LOW);
digitalWrite(pinosLEDs[1], LOW);
digitalWrite(pinosLEDs[2], LOW);
digitalWrite(pinosLEDs[3], LOW);
delay(100);
}
noTone(pinoAudio);
perdeu_o_jogo = true;
}
}
E, por fim, temos o c´odigo para reiniciar o jogo.
void tocarSomDeInicio() {
tone(pinoAudio, tons[0]);
digitalWrite(pinosLEDs[0], HIGH);
digitalWrite(pinosLEDs[1], HIGH);
digitalWrite(pinosLEDs[2], HIGH);
digitalWrite(pinosLEDs[3], HIGH);
delay(500);
digitalWrite(pinosLEDs[0], LOW);
digitalWrite(pinosLEDs[1], LOW);
digitalWrite(pinosLEDs[2], LOW);
digitalWrite(pinosLEDs[3], LOW);
delay(500);
noTone(pinoAudio);
}
32](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-33-320.jpg)
![#include <VirtualWire.h>
char info[30];
int index = 0;
char inChar;
Agora definimos o pino digital 6 como sa´ıda e como transmissor de dados. Definimos tamb´em
a sua taxa de transmiss˜ao de 2000 bps e a comunica¸c˜ao serial com 9600 baud.
void setup() {
pinMode(6,OUTPUT);
Serial.begin(9600);
vw_set_tx_pin(6);
vw_set_ptt_inverted(true);
vw_setup(2000);
}
Chegamos ent˜ao na parte final. Nessa etapa leremos cada valor char na vari´avel inChar e
a armazenaremos no vetor info[index].
void loop()
{
if (Serial.available() > 0) {
while (1) {
inChar = Serial.read();
info[index] = inChar;
index++;
delay(2);
Agora temos a fase de envio dos dados lidos na etapa anterior. Ap´os a palavra que foi
digitada na interface Serial Monitor ser lida e armazenada no vetor info enviamos os dados
armazenados no vetor pelo pino tx.
if (Serial.available() <= 0) {
index = 0;
const char *msg = info;
vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx();
memset( &info, 0, sizeof(info) );
break;
}
}
}
}
C´odigo Arduino Receptor
Como no Arduino Transmissor importaremos tamb´em o c´odigo do Arduino Receptor `a
biblioteca VirtualWire.h. Definimos o vetor info, que armazenar´a os valores char, e os pinos
que ligaremos os LEDs.
46](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-47-320.jpg)
![#include <VirtualWire.h>
char info[30];
int amarelo = 2;
int verde = 3;
int vermelho = 4;
Nessa etapa definimos os pinos de entrada e sa´ıda, a taxa de transmiss˜ao serial de 9600
baud, a taxa de recep¸c˜ao RF de 2000 bps e o seu respectivo pino 7.
void setup()
{
pinMode(7,INPUT);
pinMode(amarelo, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(vermelho, OUTPUT);
vw_set_rx_pin(7);
vw_set_ptt_inverted(true);
vw_setup(2000);
vw_rx_start();
}
Definidas as vari´aveis e as taxas de transmiss˜ao iniciamos a leitura dos dados recebidos.
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
int i;
for (i = 0; i < buflen; i++)
{
info[i]=buf[i];
}
Com os valores char armazenados no vetor info podemos agora utiliz´a-lo em uma estrutura
de compara¸c˜oes para o acionamento dos LEDs conectados ao Arduino.
if (String(info) == "amarelo on") {
digitalWrite(amarelo, HIGH);
}
if (String(info) == "amarelo off") {
digitalWrite(amarelo, LOW);
}
47](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-48-320.jpg)
![https://launchpad.net/python-uinput/+download
Feito isso, devemos descompactar o arquivo escrevendo, no terminal:
tar -vzxf python-uinput-0.10.0.tar.gz
Agora, j´a possu´ımos o arquivo necess´ario para a instala¸c˜ao. Instalamos, no terminal, atrav´es
de:
python setup.py build
python setup.py install
Muitas vezes pode-se ter problemas com permiss˜oes de pastas para instalar a biblioteca do
Python. No caso, trocando a linha de comando por:
sudo python setup.py install
pode resolver o problema.
J´a temos a biblioteca instalada. Agora j´a podemos escrever o c´odigo em Python. Come¸ca-
mos importando tudo que ´e necess´ario para o programa. Em seguida, devemos indicar quais
teclas utilizaremos, o que ´e realizado atrav´es de:
device = uinput.Device([uinput.KEY_LEFT, uinput.KEY_RIGHT])
Ou seja, utilizaremos as teclas de seta (direita e esquerda).
Feito isso, definimos a porta do Serial. Normalmente, ´e a porta /dev/ttyACM0. Ap´os
armazenarmos o valor lido da porta Serial (que definimos que escrever´ıamos ‘1’ ou ‘2’), podemos
decidir qual bot˜ao simular no Linux. Caso lermos o valor ’1’, enviaremos o bot˜ao seta direita
para o Linux, pois o Arduino detectou que foi apertado o bot˜ao seta para cima. Para o valor
’2’, enviaremos o bot˜ao seta esquerda. O nome do arquivo deve ter extens˜ao .py. Dessa forma,
o c´odigo fica da seguinte maneira:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os,serial,commands,time # Importa bibliotecas
import uinput # Importa biblioteca
device = uinput.Device([uinput.KEY_LEFT, uinput.KEY_RIGHT])
porta = ’/dev/ttyACM0’ # Define porta do arduino
while (True): # Repeti¸c~ao infinita
52](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-53-320.jpg)
![Figura 5.19: Circuito de acoplamento para Lˆampada 110V.
pino de sa´ıda do Arduino, o transistor passa a conduzir acionando um rel´e que quando fechado
liga a lˆampada conectada ao mesmo.
O diodo conectado em paralelo ao rel´e funciona como componente de prote¸c˜ao, j´a que
quando desligamos o rel´e o mesmo passa a conduzir uma corrente instantˆanea muito alta que
poderia queimar o transistor.
O c´odigo:
Abaixo explicaremos o c´odigo programado no Arduino. Iniciamos enunciando as bibliotecas
utilizadas. No caso as bibliotecas SPI.h e Ethernet.h. Logo ap´os definimos os endere¸cos MAC,
IP e a porta de comunica¸c˜ao utilizada.
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
byte ip[] = { 192, 168, 1, 177 };
Server server(180);
Definiremos agora as vari´aveis e os pinos de controle utilizados. Ligaremos o cooler ao pino
3 e a lˆampada ao pino 4.
int cooler = 3;
int lampada = 4;
char c = 0;
char command[2] = "0";
Logo ap´os iniciaremos a comunica¸c˜ao Ethernet, e definiremos os pinos da lˆampada e do
cooler como sa´ıda.
void setup()
{
Ethernet.begin(mac, ip);
server.begin();
56](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-57-320.jpg)
![client.println("<br/><p>");
break;
}
if (c == ’n’) {
current_line_is_first = false;
current_line_is_blank = true;
}
else if (c != ’r’) {
current_line_is_blank = false;
}
if (current_line_is_first && c == ’=’) {
for (int i = 0; i < 1; i++) {
c = client.read();
command[i] = c;
}
Agora criamos a etapa de controle. De acordo com cada valor enviado pela p´agina o Arduino
responder´a de maneira diferente. Temos como exemplo o bot˜ao cooler on que quando acionado
envia o valor 1 e nessa estrutura liga o cooler. Quando acionamos o bot˜ao cooler off o valor
enviado ser´a 2 que tem o efeito de desligar o cooler. Esses valores foram definidos na etapa de
constru¸c˜ao dos bot˜oes e poderiam ser quaisquer.
if (!strcmp(command, "1")) {
digitalWrite(cooler, HIGH);
}
else if (!strcmp(command, "2")) {
digitalWrite(cooler, LOW);
}
if (!strcmp(command, "3")) {
digitalWrite(lampada, HIGH);
}
else if (!strcmp(command, "4")) {
digitalWrite(lampada, LOW);
}
}
}
}
delay(1000);
client.stop();
}
Chegamos a parte final em que fechamos a p´agina.
client.println("</body>");
}
58](https://image.slidesharecdn.com/tutarduino-190319103409/85/Tut-arduino-59-320.jpg)
Tut arduino
- 1. Universidade Federal Fluminense – UFF Escola de Engenharia – TCE Curso de Engenharia de Telecomunica¸c˜oes – TGT Programa de Educa¸c˜ao Tutorial – PET Grupo PET-Tele Tutoriais PET-Tele Introdu¸c˜ao ao kit de desenvolvimento Arduino (Vers˜ao: A2013M10D02) Autores: Roberto Brauer Di Renna (2013) Rodrigo Duque Ramos Brasil (2013) Thiago Elias Bitencourt Cunha (2013) Mathyan Motta Beppu (2010) Erika Guimar˜aes Pereira da Fonseca (2010) Tutor: Alexandre Santos de la Vega Niter´oi – RJ Junho / 2013
- 2. Sum´ario 1 Introdu¸c˜ao ao Arduino 2 2 Caracter´ısticas do kit Duemilanove 4 2.1 Caracter´ısticas b´asicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Alimenta¸c˜ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.3 Mem´oria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.4 Entrada e Sa´ıda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.5 Comunica¸c˜ao serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.6 Programa¸c˜ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.7 Reset Autom´atico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.8 Prote¸c˜ao contra sobrecorrente USB . . . . . . . . . . . . . . . . . . . . . . . . . 7 3 Programa¸c˜ao do Arduino 8 3.1 Linguagem de referˆencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 3.2 Fun¸c˜oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 3.3 Bibliotecas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 4 Instala¸c˜ao da IDE do Arduino e das suas bibliotecas 13 4.1 Arduino para Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 4.2 Arduino para GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 5 Exemplos de projetos 15 5.1 Exemplo 1 - Acionamento de LED interno . . . . . . . . . . . . . . . . . . . . . 15 5.2 Exemplo 2 - Acionamento de LEDs externos . . . . . . . . . . . . . . . . . . . . 17 5.3 Exemplo 3 - Capac´ımetro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 5.4 Exemplo 4 - Controle de servomotor . . . . . . . . . . . . . . . . . . . . . . . . 22 5.5 Exemplo 5 - Teclado virtual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 5.6 Exemplo 6 - Jogo Genius . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 5.7 Exemplo 7 - Alarme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 5.8 Exemplo 8 - Controle remoto . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 5.9 Exemplo 9 - Sensor de Temperatura . . . . . . . . . . . . . . . . . . . . . . . . . 36 5.10 Exemplo 10 - Sensor de Luminosidade . . . . . . . . . . . . . . . . . . . . . . . 40 5.11 Exemplo 11 - Transmissor e Receptor RF . . . . . . . . . . . . . . . . . . . . . . 43 5.12 Exemplo 12 - Intera¸c˜ao com Python e Linux . . . . . . . . . . . . . . . . . . . . 48 5.13 Exemplo 13 - WEB Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 5.13.1 Circuito de acoplamento do cooler . . . . . . . . . . . . . . . . . . . . . . 53 5.13.2 Circuito de acoplamento para Lˆampada 110v . . . . . . . . . . . . . . . . 54 5.14 Exemplo 14 - Display de 7 segmentos I2C . . . . . . . . . . . . . . . . . . . . . 58 5.15 Exemplo 15 - LCD 16x2 I2C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 1
- 3. 5.16 Exemplo 16 - Emissor e Receptor infravermelho . . . . . . . . . . . . . . . . . . 70 5.17 Exemplo 17 - Arduino stand-alone . . . . . . . . . . . . . . . . . . . . . . . . . 73 6 Referˆencias bibliogr´aficas 78 2
- 4. Cap´ıtulo 1 Introdu¸c˜ao ao Arduino O Arduino faz parte do conceito de hardware e software livre e est´a aberto para uso e contribui¸c˜ao de toda sociedade. O conceito Arduino surgiu na It´alia, em 2005, com o objetivo de criar um dispositivo que fosse utilizado em projetos/prot´otipos constru´ıdos de uma forma menos dispendiosa do que outros sistemas dispon´ıveis no mercado. Ele pode ser usado para desenvolver artefatos interativos stand-alone ou conectados ao computador, utilizando diversos aplicativos, tais como: Adobe Flash, Processing, Max/MSP, Pure Data ou SuperCollider. O Arduino foi projetado com a finalidade de ser de f´acil entendimento, de f´acil programa¸c˜ao e de f´acil aplica¸c˜ao, al´em de ser multiplataforma, podendo ser configurado em ambientes Linux, Mac OS e Windows. Al´em disso, um grande diferencial deste dispositivo ´e ser mantido por uma comunidade que trabalha na filosofia open-source, desenvolvendo e divulgando gratuitamente seus projetos. O equipamento ´e uma plataforma de computa¸c˜ao f´ısica: s˜ao sistemas digitais ligados a sen- sores e atuadores, que permitem construir sistemas que percebam a realidade e respondem com a¸c˜oes f´ısicas. Ele ´e baseado em uma placa microcontrolada, com acessos de Entrada/Sa´ıda (I/O), sobre a qual foram desenvolvidas bibliotecas com fun¸c˜oes que simplificam a sua progra- ma¸c˜ao, por meio de uma sintaxe similar `a das linguagens C e C++. O Arduino utiliza o microcontrolador Atmega. Um microcontrolador (tamb´em denominado MCU) ´e um computador em um chip, que cont´em um microprocessador, mem´oria e perif´ericos de entrada/sa´ıda. Ele pode ser embarcado no interior de algum outro dispositivo, que, neste caso, ´e o Arduino, para que possa controlar suas fun¸c˜oes ou a¸c˜oes. Em resumo, o Arduino ´e um kit de desenvolvimento, que pode ser visto como uma unidade de processamento capaz de mensurar vari´aveis do ambiente externo, transformadas em um sinal el´etrico correspondente, atrav´es de sensores ligados aos seus terminais de entrada. De posse da informa¸c˜ao, ele pode process´a-la computacionalmente. Por fim, ele pode ainda atuar no controle ou no acionamento de algum outro elemento eletro-eletrˆonico conectado ao terminal de sa´ıda. A Figura 1.1 apresenta um diagrama de blocos de uma cadeia de processamento utilizando o Arduino. Figura 1.1: Diagrama de blocos de uma cadeia de processamento utilizando o Arduino. 3
- 5. Uma vez que o Arduino ´e baseado em um microcontrolador e, portanto, ´e program´avel, torna-se poss´ıvel criar diversas aplica¸c˜oes diferentes com uma certa facilidade. Al´em disso, o pr´oprio equipamento pode ser reutilizado, atrav´es de uma nova programa¸c˜ao. Por sua vez, a sua programa¸c˜ao ´e simplificada pela existˆencia de diversas fun¸c˜oes que controlam o dispositivo, com uma sintaxe similar `a de linguagens de programa¸c˜ao comumente utilizadas (C e C++). Assim sendo, em um ambiente profissional, as caracter´ısticas do Arduino fazem dele uma boa ferramenta de prototipa¸c˜ao r´apida e de projeto simplificado. Por outro lado, em um ambiente acadˆemico, ele pode ser perfeitamente utilizado como ferramenta educacional, uma vez que n˜ao requer do usu´ario conhecimentos profundos de eletrˆonica digital nem da programa¸c˜ao de dispositivos digitais espec´ıficos. 4
- 6. Cap´ıtulo 2 Caracter´ısticas do kit Duemilanove O kit Arduino Duemilanove (2009 em italiano) ´e uma placa baseada no microcontrolador ATmega168 ou ATmega328. Ele possui 14 pinos de entrada/sa´ıda digital (dos quais 6 podem ser utilizados como sa´ıdas PWM), 6 entradas anal´ogicas, um oscilador a cristal de 16 MHz, uma conex˜ao USB para programa¸c˜ao, uma tomada de alimenta¸c˜ao, um conector ICSP e um bot˜ao de reinicializa¸c˜ao (reset). Para sua utiliza¸c˜ao, basta conect´a-lo a um computador com um cabo USB ou lig´a-lo com um adaptador AC/DC ou a uma bateria. 2.1 Caracter´ısticas b´asicas A Tabela 2.1 apresenta as caracter´ısticas b´asicas do Arduino Duemilanove. Microcontrolador ATmega328 / ATmega168 Pinos de entrada anal´ogica 6 Pinos de I/O digitais 14 (dos quais 6 podem ser sa´ıdas PWM) Tens˜ao operacional 5 V Tens˜ao de alimenta¸c˜ao (recomendada) 7 – 12 V Tens˜ao de alimenta¸c˜ao (limites) 6 – 20 V Corrente cont´ınua por pino de I/O 40 mA Corrente cont´ınua para o pino 3.3 V 50 mA Mem´oria flash 32 KB (2KB usados para o bootloader) / 16 KB SRAM 2 KB EEPROM 1 KB Freq¨uˆencia de clock 16 MHz Tabela 2.1: Caracter´ısticas b´asicas do Arduino Duemilanove. 2.2 Alimenta¸c˜ao O Arduino Duemilanove pode ser alimentado pela conex˜ao USB ou por qualquer fonte de alimenta¸c˜ao externa. A fonte de alimenta¸c˜ao ´e selecionada automaticamente. A alimenta¸c˜ao externa (n˜ao-USB) pode ser tanto de uma fonte ou de uma bateria. A fonte pode ser conectada com um plug P4 de 2, 1 mm (centro positivo) no conector de alimenta¸c˜ao. 5
- 7. Cabos vindos de uma bateria podem ser inseridos nos pinos GND (terra) e Vin (entrada de tens˜ao) do conector de alimenta¸c˜ao. A placa pode operar com uma alimenta¸c˜ao externa de 6 a 20 V. Entretanto, se a alimenta¸c˜ao for inferior a 7 V o pino 5 V pode fornecer menos de 5 V e a placa pode ficar inst´avel. Se a alimenta¸c˜ao for superior a 12 V o regulador de tens˜ao pode superaquecer e avariar a placa. A alimenta¸c˜ao recomendada ´e de 7 a 12 V. Os pinos de alimenta¸c˜ao s˜ao: • Vin: entrada de alimenta¸c˜ao para a placa Arduino quando uma fonte externa for utilizada. Vocˆe pode fornecer alimenta¸c˜ao por este pino ou, se usar o conector de alimenta¸c˜ao, acessar a alimenta¸c˜ao por este pino; • 5V: A fonte de alimenta¸c˜ao utilizada para o microcontrolador e para outros componentes da placa. Pode ser proveniente do pino Vin atrav´es de um regulador on-board ou ser fornecida pela porta USB; • 3V3: alimenta¸c˜ao de 3, 3 V fornecida pelo circuito integrado FTDI (controlador USB). A corrente m´axima ´e de 50 mA; • GND (ground): pino terra. 2.3 Mem´oria O ATmega328 tem 32 KB de mem´oria flash (onde s˜ao armazenados os programas), al´em de 2 KB de SRAM (onde ficam as vari´aveis) e 1 KB of EEPROM (esta ´ultima pode ser lida e escrita atrav´es da biblioteca EEPROM e guarda os dados permanentemente, mesmo que desliguemos a placa). A mem´oria SRAM ´e apagada toda vez que desligamos o circuito. 2.4 Entrada e Sa´ıda Cada um dos 14 pinos digitais do Duemilanove pode ser usado como entrada ou sa´ıda, usando as fun¸c˜oes de pinMode(), digitalWrite(), e digitalRead(). Eles operam com 5 V. Cada pino pode fornecer ou receber um m´aximo de 40 mA e tem um resistor pull-up interno (desconectado por padr˜ao) de 20-50 kΩ. Al´em disso, alguns pinos tˆem fun¸c˜oes especializadas: • Serial: 0 (RX) e 1 (TX). Usados para receber (RX) e transmitir (TX) dados seriais TTL. Estes pinos s˜ao conectados aos pinos correspondentes do chip serial FTDI USB-to-TTL. • PWM: 3, 5, 6, 9, 10, e 11. Fornecem uma sa´ıda anal´ogica PWM de 8 bits com a fun¸c˜ao analogWrite(). • SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estes pinos suportam comunica¸c˜ao SPI, que embora compat´ıvel com o hardware, n˜ao est´a inclu´ıda na linguagem do Arduino. • LED: 13. H´a um LED j´a montado e conectado ao pino digital 13. O Duemilanove tem 6 entradas anal´ogicas, cada uma delas est´a ligada a um conversor anal´ogico-digital de 10 bits, ou seja, transformam a leitura anal´ogica em um valor dentre 1024 possibilidades (exemplo: de 0 a 1023). Por padr˜ao, elas medem de 0 a 5 V, embora seja poss´ıvel mudar o limite superior usando o pino AREF e um pouco de c´odigo de baixo n´ıvel. Adicionalmente alguns pinos tˆem funcionalidades especializadas: 6
- 8. • I2C: 4 (SDA) e 5 (SCL). Suportam comunica¸c˜ao I2C (TWI) usando a biblioteca Wire. • AREF. referˆencia de tens˜ao para entradas anal´ogicas. Usados com analogReference(). • Reset. Envia o valor LOW para o pino 1 do microcontrolador reiniciando-o. 2.5 Comunica¸c˜ao serial A comunica¸c˜ao entre o Arduino Duemilanove com computador ou com outro Arduino ou com outros microcontroladores ´e muito simplificada. O ATmega328 permite comunica¸c˜ao serial no padr˜ao UART TTL (5 V), que est´a dispon´ıvel nos pinos digitais 0 (RX) e 1 (TX). Um chip FTDI FT232RL na placa encaminha esta comunica¸c˜ao serial atrav´es 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(Serial Monitor) que permite que dados simples de texto sejam enviados e recebidos `a placa Arduino. Os LEDs RX e TX da placa piscam quando os dados est˜ao sendo transferidos ao computador pelo chip FTDI e h´a conex˜ao USB (mas n˜ao quando h´a comunica¸c˜ao serial pelos pinos 0 e 1). A biblioteca SoftwareSerial permite comunica¸c˜ao serial por quaisquer dos pinos digitais do Duemilanove. O ATmega328 tamb´em oferece suporte aos padr˜oes de comunica¸c˜ao I2C (TWI) e SPI. O software do Arduino inclui uma biblioteca Wire para simplificar o uso do barramento I2C. Para usar a comunica¸c˜ao SPI, veja o manual do ATmega328. 2.6 Programa¸c˜ao O ambiente de programa¸c˜ao mais indicado ´e o do software Arduino, que pode ser baixado no seguinte site: http://www.arduino.cc/en/Main/Software. Mais detalhes sobre a programa¸c˜ao do Ardu´ıno ser˜ao apresentados no Cap´ıtulo 3. 2.7 Reset Autom´atico Algumas vers˜oes anteriores do Arduino requerem um reset f´ısico (pressionando o bot˜ao de reset na placa) antes de carregar o programa a ser compilado, denominado de sketch. O Arduino Duemilanove ´e projetado de modo a permitir que isto seja feito atrav´es do software que esteja rodando no computador conectado. Uma das linhas de controle de hardware (DTR) do FT232RL est´a conectada ao reset do ATmega328 via um capacitor de 100 µF. Quando esta linha ´e colocada em n´ıvel l´ogico baixo, o sinal cai por tempo suficiente para reiniciar o chip. O software Arduino usa esta caracter´ıstica para permitir carregar o programa simplesmente pressionando o bot˜ao “upload” no ambiente Arduino. Isto significa que o bootloader pode ter um timeout mais curto, j´a que a ativa¸c˜ao do DTR (sinal baixo) pode ser bem coordenada com o in´ıcio do upload. Estas configura¸c˜oes tˆem outras implica¸c˜oes. Quando o Duemilanove est´a conectado a um computador rodando Mac OS X ou GNU/Linux, ele reinicia toda vez que a conex˜ao ´e feita por software (via USB). No pr´oximo meio segundo aproximadamente, o bootloader estar´a rodando no Duemilanove. Considerando que ´e programado para ignorar qualquer coisa a n˜ao ser um upload de um novo c´odigo, ele interceptar´a os primeiros bytes de dados sendo enviados para a placa depois que a conex˜ao ´e aberta. Se um sketch rodando na placa recebe configura¸c˜oes de 7
- 9. uma vez ou outros dados ao iniciar, assegure-se que o software que esteja comunicando espere um segundo depois de aberta a conex˜ao antes de enviar estes dados. O Duemilanove tem uma trilha que pode ser cortada para desabilitar o auto-reset e pode ser ressoldada para reativ´a-lo, ´e chamada de “RESET-EN”, vocˆe pode tamb´em desabilitar o auto-reset conectando um resistor de 110 Ω dos +5 V at´e o sinal de reset. 2.8 Prote¸c˜ao contra sobrecorrente USB O Arduino Duemilanove tem um polifus´ıvel que protege a porta USB do seu computador contra curtocircuito e sobrecorrente. Apesar da maioria dos computadores possu´ırem prote¸c˜ao interna pr´opria, o fus´ıvel proporciona uma prote¸c˜ao extra. Se mais de 500 mA forem aplicados na porta USB, o fus´ıvel ir´a automaticamente interromper a conex˜ao at´e que o curto ou a sobrecarga seja removida. 8
- 10. Cap´ıtulo 3 Programa¸c˜ao do Arduino Nesse cap´ıtulo iremos fazer uma pequena introdu¸c˜ao sobre como s˜ao estruturados os progra- mas para o Arduino, conhecendo a linguagem usada como referˆencia e suas principais fun¸c˜oes. E por fim veremos as funcionalidades extras que o uso de bibliotecas nos proporciona. 3.1 Linguagem de referˆencia Os programas para o Arduino s˜ao implementados tendo como referˆencia a linguagem C++. Preservando sua sintaxe cl´assica na declara¸c˜ao de vari´aveis, nos operadores, nos ponteiros, nos vetores, nas estruturas e em muitas outras caracter´ısticas da linguagem. Com isso, temos as referˆencias da linguagem. Elas podem ser divididas em trˆes partes principais: As estruturas, os valores (vari´aveis e constantes) e as fun¸c˜oes. As estruturas de referˆencias s˜ao: • Estruturas de controle (if, else, break, ...) • Sintaxe b´asica (#define, #include, ; , ...) • Operadores aritm´eticos e de compara¸c˜ao (+, -, =, ==, !=, ...) • Operadores booleanos (&&, ||, !) • Acesso a ponteiros (*, &) • Operadores compostos (++, –, +=, ...) • Operadores de bits (|, ˆ, , ...) Os valores de referˆencias s˜ao: • Tipos de dados(byte, array, int , char , ...) • Convers˜oes(char(), byte(), int(), ...) • Vari´avel de escopo e de qualifica¸c˜ao (variable scope, static, volatile, ...) • Utilit´arios (sizeof(), diz o tamanho da vari´avel em bytes) ´E bom citar que o software que vem no Arduino j´a provˆe v´arias fun¸c˜oes e constantes para facilitar a programa¸c˜ao, tais como: 9
- 11. • setup() • loop() • Constantes (HIGH | LOW , INPUT | OUTPUT , ...) • Bibliotecas (Serial, Servo, Tone, etc.) 3.2 Fun¸c˜oes As fun¸c˜oes s˜ao referˆencias essenciais para o desenvolvimento de um projeto usando o Ar- duino, principalmente para os iniciantes no assunto. Essas fun¸c˜oes j´a implementadas e dispon´ı- veis em bibliotecas direcionam e exemplificam as funcionalidades b´asicas do microcontrolador. Temos como fun¸c˜oes b´asicas e de referˆencias as seguintes fun¸c˜oes: • Digital I/O pinMode() digitalWrite() digitalRead() • Anal´ogico I/O analogReference() analogRead() analogWrite() - PWM • Avan¸cado I/O tone() noTone() shiftOut() pulseIn() • Tempo millis() micros() delay() delayMicroseconds() • Matem´atica min() max() abs() constrain() map() pow() sqrt() 10
- 12. • Trigonom´etrica sin() cos() tan() • N´umeros aleat´orios randomSeed() random() • bits e Bytes lowByte() highByte() bitRead() bitWrite() bitSet() bitClear() bit() • Interrup¸c˜oes externas attachInterrupt() detachInterrupt() • Interrup¸c˜oes interrupts() noInterrupts() • Comunica¸c˜ao Serial Serial.read() SerialEvent() 3.3 Bibliotecas O uso de bibliotecas nos proporciona um horizonte de programa¸c˜ao mais amplo e diverso quando comparado a utiliza¸c˜ao apenas de estruturas, valores e fun¸c˜oes. Isso ´e percept´ıvel quando analisamos os assuntos que s˜ao abordados por cada biblioteca em espec´ıfico. Lembrando sempre que, para se fazer uso de uma biblioteca, esta j´a deve estar instalada e dispon´ıvel na sua m´aquina. Temos as seguintes bibliotecas de referˆencia: • EEPROM - para reprogramar a mem´oria de armazenamento permanente. • Ethernet - para se conectar a uma rede Ethernet usando o Arduino Ethernet Shield. • Firmata - para se comunicar com os aplicativos no computador usando o protocolo Fir- mata. 11
- 13. • LiquidCrystal - para controlar telas de cristal l´ıquido (LCDs). • Servo - para controlar servomotores. • SPI - para se comunicar com dispositivos que utilizam a Serial Peripheral Interface (SPI). • SoftwareSerial - para a comunica¸c˜ao serial em qualquer um dos pinos digitais. • Stepper - para controlar motores de passo. • Wire (Two Wire Interface – TWI/I2C) - para enviar e receber dados atrav´es de uma rede de dispositivos ou sensores. Temos como referˆencia tamb´em, o uso de bibliotecas mais espec´ıficas. O que ´e de extrema importˆancia quando se faz o uso do arduino com um enfoque em uma determinada ´area. Como por exemplo: Comunica¸c˜ao (redes e protocolos) • Messenger - para o processamento de mensagens de texto a partir do computador. • NewSoftSerial - uma vers˜ao melhorada da biblioteca SoftwareSerial. • OneWire -dDispositivos de controle que usam o protocolo OneWire. • PS2Keyboard -ler caracteres de um PS2 teclado. • Simple Message System - enviar mensagens entre Arduino e o computador. • SSerial2Mobile - enviar mensagens de texto ou de e-mail, usando um telefone celular. • Webduino - biblioteca que cria um servidor Web (para uso com o Arduino Ethernet Shield). • X10 - envio de sinais X10 nas linhas de energia AC. • XBee - para se comunicar via protocolo XBee. • SerialControl - controle remoto atrav´es de uma conex˜ao serial. 12
- 14. Sensoriamento • Capacitive Sensing - Transformar dois ou mais pinos em sensores capacitivos. • Debounce - Leitura de ru´ıdos na entrada digital. Gera¸c˜ao de Freq¨uˆencia e de ´Audio • Tone - Gerar ondas quadradas de freq¨uˆencia de ´audio em qualquer pino do microcontro- lador. Temporiza¸c˜ao • DateTime - Uma biblioteca para se manter informado da data e hora atuais do software. • Metro - Ajuda ao programador a acionar o tempo em intervalos regulares. • MsTimer2 - Utiliza o temporizador de 2 de interrup¸c˜ao para desencadear uma a¸c˜ao a cada N ms. Utilidades • TextString (String) - Manipular strings • PString - uma classe leve para imprimir em buffers. • Streaming - Um m´etodo para simplificar as declara¸c˜oes de impress˜ao. 13
- 15. Cap´ıtulo 4 Instala¸c˜ao da IDE do Arduino e das suas bibliotecas Neste cap´ıtulo iremos explicar como instalar a IDE e conectar a placa Arduino ao compu- tador para sua programa¸c˜ao. Junto com a placa Arduino vocˆe deve ter um cabo USB tipo AB para poder conect´a-lo ao computador. 4.1 Arduino para Windows Primeiramente deve-se baixar o ambiente para o Arduino que pode ser encontrado no se- guinte site: http://www.arduino.cc/en/Main/Software, em Download clique em Windows e baixe o arquivo arduino-0018.zip (ou mais novo), ser´a necess´ario um programa capaz de des- compactar o arquivo (exemplos: WinZip, WinRAR, etc.). Certifique-se de preservar a estrutura da pasta. Dˆe um duplo clique na pasta para abr´ı-la, haver´a uns arquivos e sub-pastas, clique no aplicativo arduino, este ser´a seu ambiente de desenvolvimento. Conecte a placa ao computador atrav´es do cabo USB, o LED verde na placa nomeado por PWR deve ascender, ele indica que a placa est´a ligada. O arduino seleciona automaticamente a fonte de alimenta¸c˜ao adequada. Quando se conecta a placa, o Windows dever´a iniciar o processo de instala¸c˜ao do driver. No Windows vista, o driver deve ser baixado e instalado automaticamente. No Windows XP o assistente Adicionar Novo Hardware ser´a aberto: • Quando o Windows perguntar se pode se conectar ao Windows Update para procurar o software selecione N˜AO, clique em Avan¸car. • Selecione personalizar, logo ap´os selecione instalar e clique em Avan¸car. • Certifique-se de procurar o melhor driver, desmarque a pesquisa de m´ıdia remov´ıvel; selecione Incluir este local na pesquisa e procure os drivers /FTDI USB Drivers nos diret´orios de distribui¸c˜ao do Arduino. Clique em Avan¸car. • O assistente ir´a procurar o driver e em seguida, dizer que um hardware foi encontrado. Clique em Concluir. • O assistente de novo hardware abrir´a novamente, fa¸ca todos os passos da mesma maneira, desta vez, uma porta serial USB ser´a encontrada. 14
- 16. 4.2 Arduino para GNU/Linux Para a instala¸c˜ao da IDE e suas bibliotecas no sistema operacional Linux, assim como feito para o Windows, podemos baixar o arquivo compactado atrav´es do seguinte site: http://www.arduino.cc/en/Main/Software. Apenas vale resaltar que neste sistema operacional temos um tratamento diferente com rela¸c˜ao a manipula¸c˜ao de pastas e diret´orios, agora o arquivo baixado ´e “tar.gz”. Al´em desta forma de instala¸c˜ao, temos uma outra mais objetiva para executar o mesmo procedimento, esta ´ultima usando apenas o terminal. Veremos um passo a passo deste proce- dimento usando o Linux Ubuntu. Links usados: • http://www.arduino.cc/playground/Linux/Ubuntu • https://launchpad.net/ arduino-ubuntu-team/+archive/ppa • https://launchpad.net/+help/soyuz/ppa-sources-list.html Passo a Passo da instala¸c˜ao no Ubuntu • O primeiro passo ´e com o terminal aberto digitar o comando: sudo add-apt-repository ppa:arduino-ubuntu-team/ppa • Com o t´ermino do primeiro passo executamos o segundo comando digitando: sudo aptitude update • E por fim executamos o ´ultimo comando digitando: sudo aptitude install arduino • Ap´os estes trˆes passos a IDE est´a instalada e pode ser acessada pelo menu aplicati- vos/desenvolvimento/arduino Para obter informa¸c˜oes para outras distribui¸c˜oes de Linux, pesquisar no seguinte website: http://www.arduino.cc/en/Main/Software. Para Mac OS, pesquisar em http://www.arduino.cc/en/Guide/MacOSX. 15
- 17. Cap´ıtulo 5 Exemplos de projetos Neste cap´ıtulo iremos ver alguns exemplos de aplica¸c˜oes simples com o Arduino. Com uma pequena base sobre a linguagem de programa¸c˜ao C para Arduino, podemos come¸car a fazer e explicar exemplos, mesmo para quem n˜ao possua uma grande infraestrutura possa realiz´a-lo. 5.1 Exemplo 1 - Acionamento de LED interno Come¸caremos com o exemplo Blink, que j´a vem no aplicativo. Para encontrar o exemplo clique em File → Examples → Digital → Blink. O programa tem como objetivo acender e apagar o LED de um em um segundo. Para compilar este exemplo n˜ao ´e necess´ario de nenhuma outra infraestrutura que n˜ao o pr´oprio Arduino. Primeiramente, vamos criar uma vari´avel chamada ledPin que armazenar´a o n´umero da porta onde o LED est´a conectado (vari´avel do tipo inteiro): int ledPin = 13; Assim quando nos referirmos `a vari´avel ledPin estaremos nos referindo `a sa´ıda 13. O seguinte passo ´e classificar o ledPin como pino de Sa´ıda, isto ´e feito da seguinte maneira: void setup() { pinMode(ledPin, OUTPUT); } A fun¸c˜ao pinMode() tem como primeiro parˆametro o pino e como segundo parˆametro se ele ´e pino de entrada ou sa´ıda. Agora come¸caremos a escrever o processamento. O programa rodar´a em um loop, pois n˜ao h´a ocorrˆencias ou interferˆencias que mudem o estado. Dentro do loop ter´a uma fun¸c˜ao que far´a o LED ficar aceso por 1 segundo e depois ficar apagado por mais um segundo, ap´os isso volta ao loop. Escreva da seguinte maneira: void loop() { digitalWrite(ledPin, HIGH); delay(1000); digitalWrite(ledPin, LOW); delay(1000); } 16
- 18. A fun¸c˜ao digitalWrite() escreve uma informa¸c˜ao digital, ou seja, 0 (LOW) ou 1 (HIGH). Seu primeiro parˆametro ´e o pino de sa´ıda, que no caso ´e o ledPin. O segundo parˆametro ´e o estado, que no caso ´e a sa´ıda, HIGH ou LOW. Quando uma porta digital est´a em estado baixo (LOW), ela fica com 0V, j´a quando est´a em estado alto (HIGH), fica em 5 V. A fun¸c˜ao delay() ´e um atraso que se d´a para a continua¸c˜ao da leitura do programa, logo como foi escrito que o ledPin estar´a aceso, s´o ap´os um segundo, ou como est´a escrito 1000 ms, ir´a ler a linha seguinte que escreve que a sa´ıda do ledPin ´e baixa, e o mesmo ocorre mais uma vez. Antes de fazer o upload do programa, primeiro deve-se escolher a porta USB em que o Arduino se encontra. Para isso v´a em Tools → Serial Port → porta, onde porta ´e o nome da porta onde est´a ligado o Arduino (/dev/ttyUSB*, no caso de GNU/Linux, COM* em Windows). Para saber em qual porta o Arduino se encontra, fa¸ca por tentativa e erro, logo escolha um e tente rodar, caso n˜ao rode, ´e o outro. Outro passo que deve-se fazer ´e escolher o modelo da placa, para isso v´a em Tools → Board e o modelo da sua placa. Agora sim para fazer o upload, clique em Upload, como mostra a Figura 5.1. Figura 5.1: ´Icone “Upload”. 17
- 19. 5.2 Exemplo 2 - Acionamento de LEDs externos Neste exemplo, exploraremos melhor as sa´ıdas digitais. Neste exemplo ser˜ao necess´arios 10 LEDs para sua execu¸c˜ao. Os LEDs ascender˜ao em sequˆencia e ficar˜ao acesos por 1 segundo, at´e que o ´ultimo apagar´a e todos os outros em sequˆencia apagar˜ao. Para a confec¸c˜ao do projeto ligue o positivo dos LEDs nos pinos digitais de 2 ´e 11 e a outra ponta em um protoboard, no lado negativo dos LEDs ligue resistores de 150 Ω, em s´erie, e a outra ponta de todos os resistores no terra do Arduino, GND na placa. Assim como na Figura 5.2. Figura 5.2: Circuito Exemplo 2. As primeiras linhas de comando s˜ao para declara¸c˜ao de vari´aveis, iremos precisar de uma vari´avel constante e inteira de valor 10, em nosso caso chamamos de LEDCount. Outra vari´avel necess´aria ´e um vetor com 10 posi¸c˜oes, enumerados de 2 ´e 11, que s˜ao os n´umeros dos pinos de sa´ıda digital que ser˜ao utilizados que tamb´em possuem valores inteiros, chamamos o vetor de LEDPin. A seguir vem a declara¸c˜ao a ser feita: const int LEDCount = 10; int LEDPins[] = { 2, 3, 4, 5, 6, 7,8,9,10,11 }; Agora com as vari´aveis declaradas vamos definir o vetor LEDPins como pinos de sa´ıda , para isso utilizaremos um loop, da seguinte maneira: void setup() { for (int thisLED = 0; thisLED < LEDCount; thisLED++) { pinMode(LEDPins[thisLED], OUTPUT); } } Na primeira posi¸c˜ao do for declaramos uma vari´avel que inicia em 0. Na segunda posi¸c˜ao damos a condi¸c˜ao para o for, e na terceira a cada vez que ´e verificada a condi¸c˜ao do for, com execu¸c˜ao da primeira, ´e acrescido 1 ao valor de thisLED, que ´e a vari´avel que utilizaremos 18
- 20. para chamar as determinadas posi¸c˜oes do vetor LEDPins. A fun¸c˜ao pinMode(), como vista no exemplo anterior, est´a declarando que o vetor LEDPins ´e um vetor de sa´ıda de dados. Agora ser´a iniciado um loop, que far´a com que o programa sempre rode, dentro dele ter´a um for que acender´a todos os LEDs sequencialmente, com um intervalo de 1 segundo (1000 ms) entre cada LED. O corpo do programa fica da seguinte maneira: void loop() { for (int thisLED = 0; thisLED < LEDCount; thisLED++) { digitalWrite(LEDPins[thisLED], HIGH); delay(1000); } delay(1000); Perceba que o for ´e da mesma maneira que o ´ultimo, pois a id´eia ´e sempre se referir `as posi¸c˜oes do vetor, a diferen¸ca aqui ´e que para cada posi¸c˜ao estamos acendendo um LED, usando a fun¸c˜ao digitalWrite(). A fun¸c˜ao delay() foi utilizada para que seja mais f´acil de visualizar que cada LED acende de cada vez, e que ap´os todos os LEDs acenderem, todos ficam acesos por mais um segundo. Agora ser´a feito o mesmo, mas para apagar os LEDs, como mostra a seguir: for (int thisLED = 9; thisLED >= 0; thisLED--) { digitalWrite(LEDPins[thisLED], LOW); delay(1000); } delay(1000); } A vari´avel thisLED, utilizada apenas no for, come¸ca com valor 9 e ´e decrescida de 1 at´e que chegue em 0, logo os LEDs apagar´a o do ´ultimo a acender para o primeiro, e permanecer´a apagado por 1 segundo. Este foi o segundo exemplo, perceba que ´e poss´ıvel modific´a-lo com o que j´a foi aprendido, fazendo com que ele apague na mesma ordem que acende, ou fazendo qualquer outra mudan¸ca desejada. 19
- 21. 5.3 Exemplo 3 - Capac´ımetro Neste exemplo utilizaremos a entrada anal´ogica e a sa´ıda serial na confec¸c˜ao de um capac´ı- metro. Para isso ser´a necess´ario um resistor, que pode ter qualquer valor que chamaremos de R1, um resitor de 220 Ω, um capacitor, um protoboard e um fio. Ligue o positivo do capacitor em um ponto comum e o negativo no terra, o resistor R1 entre o +5 V da placa e o ponto comum, ligue o outro resistor, que chamaremos de R2 e tem o valor de 220 Ω entre o ponto comum e o pino 11, que ´e o pino que ir´a descarregar o capacitor. Ligue o fio do ponto comum a entrada anal´ogica. Figura 5.3: Circuito Exemplo 3. Iremos calcular o valor do capacitor medindo o tempo de carga. Sabemos que o valor de uma constante de tempo (τ s) ´e igual ao valor de uma resistˆencia (R Ω) multiplicado pelo valor de uma capacitˆancia (C F), e que a tens˜ao no capacitor em uma constante de tempo (vC(τ)) ´e de 63, 2% do seu valor m´aximo. Podemos calcular a capacitˆancia, pois como sabemos o valor da fonte fornecida pelo Arduino, que ´e de 5 V , basta calcularmos 63, 2% de sua tens˜ao e quando a tens˜ao no capacitor encontrar este valor basta divid´ı-la pelo valor da resistˆencia R: vC(τ) = 0, 632 Vmax = RC, onde Vmax ´e a tens˜ao m´axima. A programa¸c˜ao come¸ca com a declara¸c˜ao de vari´aveis, ou seja, um pino anal´ogico para medir tens˜ao no capacitor, um pino de carga e um de descarga do capacitor e um pino com o valor de R1, como podemos ver no exemplo a seguir: #define analogPin 0 #define chargePin 13 #define dischargePin 11 #define resistorValue R1 unsigned long startTime; unsigned long elapsedTime; float microFarads; float nanoFarads; Perceba que o valor de R1 deve ser substitu´ıdo pelo valor escolhido. 20
- 22. Devemos ajustar o pino 13 como pino de sa´ıda, como j´a foi feito em exemplos anteriores, e iniciar a sa´ıda serial a fim de depurar erros: void setup(){ pinMode(chargePin, OUTPUT); digitalWrite(chargePin, LOW); Serial.begin(9600); } No decorrer do desenvolvimento da apostila ainda n˜ao hav´ıamos mencionado a comunica¸c˜ao serial. No pr´oprio compilador Arduino-0018 existe uma interface que lhe proporciona observar a sa´ıda e entrada na pr´opria tela do computador, a Figura5.4 abaixo mostra onde ter acesso a esse recurso. Figura 5.4: ´Icone “Comunica¸c˜ao serial”. Em nosso caso utilizamos a frequˆencia de transferˆencia de dados de 9600 B/s, mas ´e poss´ıvel selecionar outros valores j´a pr´e-determinados pelo programa que podem ser observados quando se abre a comunica¸c˜ao serial. Iniciaremos o loop do programa fornecendo energia ao pino de carga do capacitor e acionando o startTime, que ´e a vari´avel que ir´a temporizar o tempo de carga do capacitor. Para poder calcular os 63, 2% da carga teremos que fazer uma convers˜ao, pois o fim da escala ´e de 1023, logo 63, 2% disso corresponde ´e 647, que ´e a porcentagem da tens˜ao m´axima no capacitor. Enquanto a entrada do pino anal´ogico n˜ao equivaler a esta porcentagem de tempo n˜ao ocorre nada, apenas a contagem de tempo de carga do capacitor, que j´a esta sendo feita pela vari´avel startTime. Quando esta porcentagem ´e ultrapassada mede-se a capacitˆancia dividindo o tempo de carga pelo valor de R1. Como ´e usual que valores de capacitˆancia sejam baixos, na ordem de mili a nano Farad, ´e mais agrad´avel que se expresse o valor em mili ou nano Farad, ou seja, multiplique o valor da capacitˆancia por 1000 e acrescente o mF no final, caso mesmo com este procedimento o valor ainda seja menor que 1, podemos utilizar outras escalas (micro, nano, etc.). A programa¸c˜ao referida pode ser observada a seguir: void loop(){ digitalWrite(chargePin, HIGH); // coloque HIGH em chargePin startTime = millis(); while (analogRead(analogPin) < 648) { } elapsedTime = millis() - startTime; microFarads = ((float)elapsedTime / resistorValue) * 1000; 21
- 23. Serial.print(elapsedTime); Serial.println(" ms"); if (microFarads > 1) { Serial.print((long)microFarads); Serial.println(" mF"); } else { nanoFarads = microFarads * 1000.0; Serial.print((long)nanoFarads); Serial.println(" nF"); } O programa j´a est´a quase conclu´ıdo, basta fazer a descarga do capacitor. Para isso “des- ligue” o chargePin, ajuste dischargePin como sa´ıda, coloque LOW at´e que o capacitor esteja descarregado, e volte a ajustar o dischargePin como entrada, da seguinte maneira: digitalWrite(chargePin, LOW); pinMode(dischargePin, OUTPUT); digitalWrite(dischargePin, LOW); while (analogRead(analogPin) > 0) { } pinMode(dischargePin, INPUT); } 22
- 24. 5.4 Exemplo 4 - Controle de servomotor Este exemplo ilustra o uso de uma das sa´ıdas PWM (Pulse-Width Modulation - Modula¸c˜ao por Largura de Pulso) do Arduino com um servomotor. Qualquer servo com um terminal de controle compat´ıvel pode ser utilizado. Aqui usaremos um polar rotor do tipo usado em antenas parab´olicas. Primeiramente ´e importante saber o que ´e PWM e o que ´e poss´ıvel fazer. PWM ´e um mecanismo que permite controlar o per´ıodo c´ıclico da frequˆencia da alimenta¸c˜ao. Figura 5.5: Exemplos de sinais PWM. Suas aplica¸c˜oes s˜ao diversas e abrangem tanto usos industriais quanto dom´esticos. Em in- d´ustrias, o PWM pode ser usado para controlar elevadores de carga, esteiras rolantes e guinchos. J´a em aplica¸c˜oes dom´esticas, pode ser usado para controle de ilumina¸c˜ao, port˜oes e cortinas. Iremos utilizar a entrada manual comandada por um potenciˆometro linear de 100 kΩ. O motor possui 3 fios: um vermelho, um preto e um branco. Os fios preto e vermelho correspondem ao negativo e positivo da alimenta¸c˜ao, respectivamente, e neste exemplo podemos conect´a-los diretamente aos pinos de alimenta¸c˜ao do Arduino. O vermelho ´e conectado ao pino 5 V, e o preto a qualquer um dos pinos GND. O fio branco ´e o terminal de controle, e deve ser conec- tado a uma das sa´ıdas digitais com PWM, qualquer um dos pinos 3, 5, 6, 9, 10 ou 11. No exemplo usaremos o 10. O potenciˆometro linear de 100 kΩ ´e conectado tendo um dos seus pinos extremos ligado ao GND, o outro extremo ao pino AREF, que fornece a tens˜ao de refe- rˆencia, e o pino central conectado a qualquer uma das entradas anal´ogicas, utilizaremos o pino 1. Desta vez usaremos uma biblioteca para suporte de servos, logo no in´ıcio do programa deveremos import´a-la. Deveremos criar um objeto do tipo servo que ser´a utilizado para controle, da seguinte maneira: #include <Servo.h> Servo meuservo; 23
- 25. Figura 5.6: Circuito Exemplo 4. A seguir, ´e feita a parte de declara¸c˜ao de vari´aveis. Iremos declarar um pino para o potenci- ˆometro e servo, e uma vari´avel inteira para o valor lido do potenciˆometro. Tamb´em deveremos iniciar o servo, que em nosso caso est´a conectado ao pino 10, como vemos a seguir: int potpin = 1; int val; void setup() { meuservo.attach(10); } Quando lermos a entrada do potenciˆometro, teremos que converter seu valor para graus para podermos controlar em graus quanto o motor ir´a girar, para isto utilizaremos a fun¸c˜ao map(). Ap´os isto apenas devemos enviar a informa¸c˜ao para o motor e esperar alguns milissegundos para a movimenta¸c˜ao do motor. void loop() { val = analogRead(potpin); val = map(val, 0, 1023, 0, 180); meuservo.write(val); delay(500); } 24
- 26. 5.5 Exemplo 5 - Teclado virtual Neste exemplo, faremos um teclado virtual. Ser˜ao necess´arios um resistor de 330 Ω e um autofalante. Teclas do computador emitir˜ao comandos para que o autofalante reproduza as notas musicais. A montagem do circuito ´e bem simples. Ligue o ground do autofalante no pino GND do Arduino. Coloque o resistor em uma protoboard e ligue o positivo do autofalante em uma ponta. Feche o circuito ligando a outra ponta do resistor a uma porta digital de sua preferˆencia (de 2 `a 13). O exemplo seguir´a com a porta de n´umero 10 (dez). Figura 5.7: Circuito Exemplo 5. As primeiras linhas de comando s˜ao de declara¸c˜ao de vari´aveis. O comando #define permite que definamos o nome que desejemos a um valor de uma constante antes do programa ser compilado. Logo, temos que: #define NOTA_DO 262 #define NOTA_RE 294 #define NOTA_MI 330 #define NOTA_FA 349 #define NOTA_SOL 392 #define NOTA_LA 440 #define NOTA_SI 494 onde NOTA_DO foi o nome escolhido para a nota d´o, e 262 Hz ´e a frequˆencia da nota musical. Ao longo da pr´atica, explicaremos o porquˆe de usar essa freq¨uˆencia. int pinoAudio = 10; int nota; onde pinoFalante e nota s˜ao nome de vari´aveis do tipo inteiro, e a pinoAudio recebeu o valor 10, pois usaremos o pino 10 no projeto. Como queremos fazer com que tenha comunica¸c˜ao entre o teclado e o circuito, devemos estabelecer a taxa com que os dados ser˜ao transmitidos. Para isso, usamos a taxa padr˜ao, que ´e de 9600 ms. 25
- 27. void setup() { Serial.begin(9600); Para n˜ao congestionar as portas, devemos esvaziar o buffer associado `a porta de entrada, assim como esvaziaremos o buffer associado `a porta de sa´ıda no final do c´odigo. Tamb´em definimos o pinoAudio como sa´ıda. Serial.flush(); pinMode(pinoAudio, OUTPUT); } Na fun¸c˜ao void loop() criaremos uma s´erie de condi¸c˜oes. A primeira delas, dada por if (Serial.available()>0), ´e uma condi¸c˜ao que faz com que o c´odigo funcione apenas caso o usu´ario digite algo. Se isso ocorrer, a fun¸c˜ao Serial.available retornar´a um valor maior que 0 e a condi¸c˜ao ser´a satisfeita. ´E importante lembrar que, para digitar algo, deve-se selecionar a guia “Tools” do Arduino, “Serial Monitor”. verb+void loop() { if (Serial.available()>0){ Decidimos por usar a vari´avel nota para receber qual tecla fora pressionada. Dessa forma, temos essa linha de c´odigo: nota=Serial.read(); Para que fique mais claro se a tecla foi pressionada e reconhecida, colocaremos a seguinte linha de c´odigo, que retornar´a a tecla digitada: Serial.println(nota); Agora, faremos as condi¸c˜oes que determinar˜ao qual tecla ir´a corresponder a qual nota mu- sical. Para isso, devemos saber qual n´umero correponde a cada tecla do teclado. No exemplo, decidimos fazer com que as 7 notas musicais correspondessem `as teclas de 1 a 7 do teclado, que correspondem `a numera¸c˜ao de 49 a 55. Para que possamos ter o efeito da nota musical, usamos a fun¸c˜ao tone. Tone gera uma onda quadrada de uma freq¨uˆencia espec´ıfica e ciclo de trabalho (duty-cycle) de 50% em um pino. A dura¸c˜ao pode ser especificada, mas, por outro lado, a onda continua enquanto a fun¸c˜ao noTone() n˜ao for utilizada. ´E poss´ıvel realizar esse trecho de c´odigo de diversas formas. No entanto, vamos usar a mesma sintaxe dos outros exemplos. S˜ao 7 notas musicais, apenas uma ser´a exemplificada, as outras necessitam apenas trocar o valor da correspondente `a tecla e o nome dado `a nota musical. if (nota==49){ /* nota sera emitida quando a tecla 1 for apertada */ tone(pinoAudio, NOTA_DO); delay(500); noTone(pinoAudio); } 26
- 28. Temos um teste onde comparamos a vari´avel nota que recebeu o valor da tecla, e o j´a determinado no c´odigo para a estrutura if. A fun¸c˜ao tone faz referˆencia ao pino escolhido, `a nota musical, no caso a D´O. Escolhemos que cada nota tenha dura¸c˜ao de meio segundo. Logo colocamos um atraso de 500 ms e paramos o som com a fun¸c˜ao noTone. Terminamos o c´odigo desta forma, onde o Serial.flush, como dito anteriormente, est´a presente para que, a cada tecla digitada, possamos esvaziar a porta de sa´ıda. Serial.flush(); } } 27
- 29. 5.6 Exemplo 6 - Jogo Genius Um jogo muito famoso na d´ecada de 1980, que buscava estimular a mem´oria do jogador atrav´es de cores e sons, ´e o Genius. O Exemplo 6 trata de uma adapta¸c˜ao desse jogo para o Arduino. Precisaremos de 4 bot˜oes, 8 resistores de 330 Ω e 4 LEDs (de preferˆencia de cores diferentes). Al´em de um autofalante. A montagem do circuito ´e bem simples, por´em como temos uma quantidade maior de fios das pr´aticas anteriores, ´e necess´aria aten¸c˜ao na montagem. Ligue o ground do autofalante em um canto da primeira e segunda fileiras da protoboard, e o positivo na porta digital 7 do Arduino. Feito isso, come¸caremos a montar o circuito. Na ponta oposta aonde fora ligado o ground do autofalante, ligue o pino GND do Arduino. Fa¸ca uma conex˜ao com um fio menor entre a primeira e segunda fileiras da protoboard com o outro bloco. Monte cada LED da forma com que o Gnd passe pelo lado inteiro do LED, passando por um resistor, e fechando em alguma porta do Arduino. Repita o processo at´e terminarem os LEDs. Feito isso, faremos o mesmo esquema do outro lado, trocando apenas os LEDs pelos bot˜oes. Figura 5.8: Circuito Exemplo 6. Primeiramente, vamos definir as vari´aveis. Para que possamos emitir sons, iremos usar os mesma fun¸c˜ao do Exemplo 5, a tone. Desta forma, definiremos os tons que ser˜ao emitidos quando apertamos os bot˜oes, os originais do Genius. #define NOTE_D4 294 #define NOTE_G4 392 #define NOTE_A4 440 #define NOTE_A5 880 Agora iremos criar vari´aveis para facilitar nossa linha de pensamento, e o programa em si. Ao inv´es de criarmos uma vari´avel para cada tom, iremos criar um vetor, que facilitar´a no momento de sortearmos. 28
- 30. Para que tenhamos um sorteio bem variado, faremos um vetor de 0 a 100. Criaremos uma vari´avel para que contemos em qual rodada estamos, para que facilite a intera¸c˜ao tons-LEDs. Al´em disso, criaremos uma vari´avel para indicar o passo atual da sequˆencia. int tons[4] = { NOTE_A4, NOTE_G4, NOTE_D4 ,NOTE_A5}; int sequencia[100] = {}; int rodada_atual = 0; int passo_atual_na_sequencia = 0; Criaremos as vari´aveis que receber˜ao quais portas os LEDs, bot˜oes e autofalante est˜ao ligados. Al´em de mais duas vari´aveis de controle, a botao pres- sionado para indicar se algum bot˜ao fora pressionado e a perdeu_o_jogo para terminar a partida. int pinoAudio = 7; int pinosLEDs[4] = { 8, 9,10,11 }; int pinosBotoes[4] = {2,3,4,5}; int botao_pressionado = 0; int perdeu_o_jogo = false; Na fun¸c˜ao void setup() iremos definir quais pinos ser˜ao de entrada e de sa´ıda, al´em de usarmos a fun¸c˜ao randˆomica randomSeed, que gera um valor vari´avel entre 0 e 1023. Ela ser´a importante para que o jogo n˜ao fique repetitivo. void setup() { for (int i = 0; i <= 3; i++) { pinMode(pinosLEDs[i], OUTPUT); } for (int i = 0; i <= 3; i++) { pinMode(pinosBotoes[i], INPUT); } pinMode(pinoAudio, OUTPUT); randomSeed(analogRead(0)); } Note que, como definimos os bot˜oes e LEDs como vetores, na fun¸c˜ao void setup() utili- zaremos a estrutura de controle for para atribuir valores iniciais para tais vetores. Agora come¸caremos a montar a estrutura do jogo propriamente dita, inicializando o loop. void loop() { if (perdeu_o_jogo) { int sequencia[100] = {}; 29
- 31. rodada_atual = 0; passo_atual_na_sequencia = 0; perdeu_o_jogo = false; } Primeiramente, faremos uma condi¸c˜ao onde zeramos todas as vari´aveis caso o jogador perca a partida. Para a condi¸c˜ao ser verdadeira, como explicado acima, usaremos a vari´avel booleana perdeu_o_jogo. Onde ela assumir´a o valor true caso o usu´ario seja derrotado pela m´aquina. Como nesse exemplo n˜ao inclu´ımos um display, para informar que come¸car´a o jogo, vamos colocar um som de in´ıcio para anunciar que ´e a primeira rodada. if (rodada_atual == 0) { tocarSomDeInicio(); delay(500); } Depois disso, devemos inicializar a pr´oxima rodada, reproduzir a sequˆencia e aguardar o jogador clicar os bot˜oes. H´a um atraso de 1 segundo entre cada jogada. proximaRodada(); reproduzirsequencia(); aguardarJogador(); delay(1000); } OBS.: Note que aqui termina nossa fun¸c˜ao Void loop(). At´e aqui, criamos a primeira rodada, onde apenas uma luz foi acesa. Em seguida, vamos adicionar mais um luz para cada rodada com a fun¸c˜ao void proximaRodada(). Sorteamos um dos LEDs a serem acesos, atrav´es da fun¸c˜ao random(), e completamos a fun¸c˜ao void atribuindo ao nosso vetor sequˆencia qual foi o valor sorteado. void proximaRodada() { int numero_sorteado = random(0, 3); sequencia[rodada_atual++] = numero_sorteado; } Anteriormente, criamos a sequˆencia. Agora, iremos reproduz´ı-la. Usaremos a estrutura de repeti¸c˜ao for para que os pinos de sa´ıda adequados sejam acionados. void reproduzirsequencia() { for (int i = 0; i < rodada_atual; i++) { tone(pinoAudio, tons[sequencia[i]]); digitalWrite(pinosLEDs[sequencia[i]], HIGH); delay(500); noTone(pinoAudio); digitalWrite(pinosLEDs[sequencia[i]], LOW); delay(100); } noTone(pinoAudio); } 30
- 32. Neste ponto, iremos verificar se o jogador acertou ou errou a sequˆencia. Caso tenha errado, o programa para e voltamos para o in´ıcio. Caso contr´ario, o programa continua, zerando o passo da sequˆencia. void aguardarJogador() { for (int i = 0; i < rodada_atual; i++) { aguardarJogada(); verificarJogada(); if (perdeu_o_jogo) { break; } passo_atual_na_sequencia++; } passo_atual_na_sequencia = 0; } Neste trecho de c´odigo temos o complemento do anterior, onde aqui damos o comando para que os ´audios e os LEDs sejam acionados quando requeridos. ´E importante destacar que quando atribu´ımos `a vari´avel botao_pressionado o valor de i, usamos esse valor para que o programa associe corretamente qual LED ser´a aceso e qual som dever´a ser reproduzido. void aguardarJogada() { boolean jogada_efetuada = false; while (!jogada_efetuada) { for (int i = 0; i <= 3; i++) { if (digitalRead(pinosBotoes[i]) == HIGH) { // Dizendo qual foi o botao pressionado. botao_pressionado = i; tone(pinoAudio, tons[i]); digitalWrite(pinosLEDs[i], HIGH); delay(300); digitalWrite(pinosLEDs[i], LOW); noTone(pinoAudio); jogada_efetuada = true; } } delay(10); } } Por ´ultimo, temos a fun¸c˜ao void verificarJogada(), que cria a condi¸c˜ao para que, caso o jogador perca, todos os LEDs pisquem rapidamente, indicando isso. void verificarJogada() { if (sequencia[passo_atual_na_sequencia] != botao_pressionado) { 31
- 33. for (int i = 0; i <= 3; i++) { tone(pinoAudio, tons[i]); digitalWrite(pinosLEDs[i], HIGH); delay(200); digitalWrite(pinosLEDs[i], LOW); noTone(pinoAudio); } tone(pinoAudio, tons[2]); for (int i = 0; i <= 3; i++) { digitalWrite(pinosLEDs[0], HIGH); digitalWrite(pinosLEDs[1], HIGH); digitalWrite(pinosLEDs[2], HIGH); digitalWrite(pinosLEDs[3], HIGH); delay(100); digitalWrite(pinosLEDs[0], LOW); digitalWrite(pinosLEDs[1], LOW); digitalWrite(pinosLEDs[2], LOW); digitalWrite(pinosLEDs[3], LOW); delay(100); } noTone(pinoAudio); perdeu_o_jogo = true; } } E, por fim, temos o c´odigo para reiniciar o jogo. void tocarSomDeInicio() { tone(pinoAudio, tons[0]); digitalWrite(pinosLEDs[0], HIGH); digitalWrite(pinosLEDs[1], HIGH); digitalWrite(pinosLEDs[2], HIGH); digitalWrite(pinosLEDs[3], HIGH); delay(500); digitalWrite(pinosLEDs[0], LOW); digitalWrite(pinosLEDs[1], LOW); digitalWrite(pinosLEDs[2], LOW); digitalWrite(pinosLEDs[3], LOW); delay(500); noTone(pinoAudio); } 32
- 34. 5.7 Exemplo 7 - Alarme O Arduino tamb´em pode simular um alarme. Utilizando um emissor e um receptor infraver- melho, h´a uma transmiss˜ao de dados. Dessa forma, podemos verificar os dados (no programa, s˜ao representados por n´umeros inteiros) e mandar o Arduino se comportar de alguma forma, caso ocorra alguma altera¸c˜ao brusca no valor. Essa altera¸c˜ao brusca no valor se d´a, geralmente, quando h´a um obst´aculo entre o emissor e o receptor IR. A montagem do circuito n˜ao ´e muito mais avan¸cada do que nos outros exemplos, apenas inseriremos o transmissor e o receptor infravermelho. No circuito montado, liga-se um buzzer em s´erie com uma resistˆencia. Por sinal, nessa atividade deveremos ligar todos os equipamentos em s´erie com uma resistˆencia (LEDs, emissor e receptor IR e buzzer). O transmissor e o receptor infravermelho dever˜ao ser ligados em paralelo e, nesse exemplo, recebendo 5 V . Repare que, para facilitar, jogamos o ground de todos os equipamentos para o mesmo fio no final. Figura 5.9: Circuito do Exemplo 7. Primeiramente, vamos definir as vari´aveis. Reparem que sensor, LEDam, LEDvm e som correspondem ao n´umero da porta de cada equipamento, enquanto u e sensor valor s˜ao vari´aveis que ser˜ao utilizadas para fins operacionais durante o c´odigo. ´E importante ressaltar que sensor indica a porta da sa´ıda anal´ogica. const int sensor = 2; const int LEDam = 13; const int LEDvm= 12; const int som= 11; int u=0; int sensor_valor = 0; Agora definiremos as portas de sa´ıda e o in´ıcio do Serial. void setup() { pinMode(LEDam, OUTPUT); pinMode(LEDvm, OUTPUT); 33
- 35. pinMode(som, OUTPUT); Serial.begin(9600); } Agora come¸ca a fun¸c˜ao de loop. Captaremos as informa¸c˜oes sendo transmitidas atrav´es da fun¸c˜ao analogRead(sensor), que s˜ao n´umeros inteiros, e armazenaremos na vari´avel sensor valor. Com Serial.print(sensor valor), verificaremos na janela do Serial Monitor o valor num´erico de sensor valor. A seguir, se sensor valor ultrapassar 1000, ´e porque houve interrup¸c˜ao na transmiss˜ao de dados e, portanto, o alarme deve ser acionado. Normalmente, o valor de transmiss˜ao varia entre 800 e 950 se n˜ao houver interrup¸c˜ao e maior que 1010 se houver. No entanto, esse valor pode ser DIFERENTE caso n˜ao se use 5 V ou coloquem um circuito com mais ou menos resistˆencias em s´erie com o emissor e/ou receptor. Esse programa foi feito para o circuito montado na imagem. Portanto, se o valor de trans- miss˜ao interrompida for diferente desses padr˜oes, vocˆe dever´a alterar o valor no comando de decis˜ao “if (sensor valor>1000)”. Lembrando que podemos ver o valor de trasmiss˜ao no Serial Monitor. void loop() { sensor_valor = analogRead(sensor); Serial.print(sensor_valor); Serial.print("n"); if (sensor_valor>1000) { u=1; } if (u==1){ tone(som, 2000); digitalWrite(LEDam, HIGH); delay(100); digitalWrite(LEDam, LOW); digitalWrite(LEDvm, HIGH); delay(100); digitalWrite(LEDvm, LOW); } Serial.flush(); } Como podemos ver, caso o alarme seja acionado, ele piscar´a as luzes e emitir´a um som at´e que o bot˜ao reset do Arduino seja apertado. 34
- 36. 5.8 Exemplo 8 - Controle remoto Em casa, controlar v´arios aparelhos eletrˆonicos atrav´es de apenas um controle remoto pode ser um desejo de muitos. O conceito de “casa inteligente” visto em muitos filmes, pode ser realizado, at´e certo ponto, utilizando um ou mais Arduinos. Neste exemplo, daremos um exemplo b´asico de controlar um LED atrav´es de um controle remoto. O circuito ´e relativamente simples, envolvendo apenas um LED, um receptor infravermelho e uma resistˆencia. Figura 5.10: Circuito do Exemplo 8. Quando apertamos um bot˜ao do controle remoto, ele envia um valor via infravermelho. Dessa forma, se utilizarmos um receptor infravermelho, podemos conseguir ler esse valor. Precisamos baixar a biblioteca com as fun¸c˜oes necess´arias para utilizar esse receptor infraver- melho, chamada NECIRrcv. Ela est´a dispon´ıvel para download em: https://www.dropbox.com/ sh/53bp7fo211hxbba/iYnG2cqfhN/Biblioteca%20NECIRrcv%20para%20controle%20remoto. Primeiramente, precisamos incluir no programa a biblioteca que baixamos, que se d´a atrav´es de “#include <NECIRrcv.h>”. Em seguida, definimos as vari´aveis e enviamos a porta que est´a ligado o receptor infravermelho para a biblioteca trabalhar em cima disso (que est´a presente em “NECIRrcv ir(InfraVermelho);”. #include <NECIRrcv.h> #define InfraVermelho 10 unsigned long int capturaCodigo = 0; int estado = 0; int LED = 7; NECIRrcv ir(InfraVermelho); Agora, definiremos as configura¸c˜oes (como sa´ıdas, iniciar o Serial e o infravermelho). void setup(){ pinMode(LED, OUTPUT); 35
- 37. Serial.begin(9600); Serial.flush(); ir.begin() ; } Na fun¸c˜ao de loop, iremos verificar se o receptor recebeu algum sinal infravermelho atrav´es de “if (ir.available()>0)”. Se receber algum sinal, capturaremos o valor atrav´es de “ir.read()” e armazenaremos na vari´avel capturaCodigo. Em seguida, imprimiremos o valor no Serial. No controle utilizado, a tecla “Power” enviava o valor 4278238976 via infravermelho. Como quer´ıamos ligar o LED atrav´es desse bot˜ao, fizemos uma condi¸c˜ao para a luz acender caso fosse recebido esse valor. Para que fosse permitido apagar utilizando o mesmo bot˜ao, criamos uma vari´avel de estado chamada estado para verificar se o LED estava aceso ou apagado e mudamos o valor da vari´avel, caso a lˆampada mudasse seu estado. void loop() { if (ir.available()>0) { capturaCodigo = ir.read(); Serial.println(capturaCodigo); if (capturaCodigo == 4278238976){ if (estado ==0) { digitalWrite(LED, HIGH); estado = 1; } else { digitalWrite(LED, LOW); estado = 0; } Serial.println(estado); } } Serial.flush(); } 36
- 38. 5.9 Exemplo 9 - Sensor de Temperatura Este projeto consiste na leitura da temperatura ambiente atrav´es do sensor LM335A. Para a montagem do circuito utilizaremos um sensor, um potˆenciometro para o ajuste e um resistor de 2, 2 KΩ. O funcionamento do circuito parte do princ´ıpio que a tens˜ao de sa´ıda do sensor de tempe- ratura ´e diretamente proporcional a temperatura absoluta a uma taxa de 10mV/◦ K. Para realizarmos tal leitura utilizaremos um Arduino Uno lendo a sa´ıda do sensor. Atrav´es de um pequeno c´alculo converteremos a tens˜ao lida em temperatura e a graficaremos nas escalas de temperatura Celsius e Kelvin na serial monitor. Para a montagem no protoboard ´e de suma importˆancia o cuidado com a correta conex˜ao dos pinos do sensor. Para isso utilizaremos a imagem abaixo como guia: Figura 5.11: Sensor de temperatura LM335A. O esquema a ser montado ´e bastante simples. Primeiramente faremos uma linha +Vcc e uma linha GND no protoboard conectando os pinos +5 V e GND do Arduino em duas trilhas diferentes. Logo ap´os ligaremos um terminal do resistor de 2, 2 KΩ na linha +Vcc e o outro terminal no pino Vs do sensor. Feito isso conectamos o pino GND do sensor na trilha GND do protoboard, faltando ent˜ao conectarmos o potenciˆometro ao pino de ajuste. Para isso ligamos o primeiro terminal do po- tenciˆometro a trilha +Vcc, o terminal do meio no pino adj do sensor e o ´ultimo terminal a trilha GND do protoboard. 37
- 39. Para terminar a montagem ligamos o pino Vs do sensor na entrada anal´ogica 0 do Arduino. O circuito resultante encontra-se logo abaixo: Figura 5.12: Circuito do projeto sensor de temperatura. 38
- 40. O c´odigo: Primeiramente definiremos as vari´aveis utilizadas no programa. Teremos as vari´aveis inteiras pinosensor com valor A0 que representa o pino de leitura anal´ogica do sensor e a vari´avel valorsensor ,que armazenar´a o valor lido, definida inicialmente com valor 0. Teremos tamb´em as vari´aveis flutuantes celsius e kelvin, que armazenar˜ao os valores das temperaturas calculadas pelo programa, definidas inicialmente com valor 0. int pinosensor = A0; int valorsensor = 0; float celsius = 0; float kelvin = 0; Agora definiremos o pino A0 como entrada, a taxa de transmiss˜ao da porta serial e uma primeira mensagem que ser´a graficada na Seral Monitor. void setup() { pinMode(pinosensor, INPUT); Serial.begin(9600); Serial.println(’Projeto sensor de temperatura:’); } Chegamos na parte final do nosso c´odigo. Nesta parte iremos armazenar o valor lido na porta anal´ogica A0 na vari´avel valorsensor. Como o Arduino mapeia tens˜oes de entrada en- tre 0 e 5 volts em valores inteiros de 0 a 1023 teremos estes valores armazenados na vari´avel valorsensor. Como queremos calcular com exatid˜ao a temperatura em ◦ K realizaremos o c´alculo “kelvin = valorsensor*500/1024;” e teremos o valor da temperatura j´a em Kelvin. O fator valorsensor∗500/1024 se explica pois a tens˜ao m´axima lida ´e de 5 volts e o temos uma escala de 1024 unidades. Teremos ent˜ao um valor de 5/1024 volts por unidade lida. Multi- plicamos o valor de cada unidade pelo n´umero de unidades armazenada na vari´avel valorsensor e teremos o valor de tens˜ao lida pelo Arduino. Para termos valor para temperatura em ◦ K multiplicamos o valor da tens˜ao calculada por 100 pois a sensibilidade do sensor de 10mV/◦ K. Agora para termos o valor da temperatura em Celsius basta subtrair o valor da temperatura em Kelvin de 273. void loop() { valorsensor = analogRead(pinosensor); kelvin = valorsensor*500/1023; celsius = kelvin - 273; Serial.print("A temperatura em Kelvin e: "); Serial.println(kelvin); Serial.print("A temperatura em Celsius e: "); Serial.println(celsius); Serial.println(’------------------------------’); delay(5000); } 39
- 41. Feita a programa¸c˜ao no Arduino teremos que realizar a calibagem do sensor. Ap´os abrir a Serial Monitor para uma primeira conferˆencia poderemos encontrar uma varia¸c˜ao de + − 6◦ C em compara¸c˜ao com um termˆometro real. Para resolvermos este problema ajustamos o potˆenciometro at´e que as temperaturas lidas pelo Arduino e pelo termˆometro coincidam. Ap´os este ajuste nosso projeto funcionar´a corretamente. 40
- 42. 5.10 Exemplo 10 - Sensor de Luminosidade O fotoresistor pode ser caracterizado pela sua capacidade de sensibilidade `a luz. Ou seja, ele muda seu valor resistivo conforme a intensidade de luz que recebe. Aproveitando isso, podemos montar um circuito que simule um aparelho de DJ. Ou seja, podemos requisitar ao Arduino que toque um som e acender uma luz toda vez fizermos sombra sobre o fotoresistor (quando ler um valor de tens˜ao relativamente baixo). Dessa forma, podemos controlar manualmente como e quando um som toca. ´E importante dizer que o resistor que est´a fazendo divisor de tens˜ao com o fotoresistor possui valor de 10 kΩ. Figura 5.13: Circuito do Exemplo 9. 41
- 43. Primeiramente, vamos definir as vari´aveis. Reparem que fotoresistor, LED e som correspon- dem ao n´umero da porta de cada equipamento, enquanto leres ´e uma vari´avel que ser´a utilizada para fins operacionais durante o c´odigo. ´E importante ressaltar que fotoresistor indica a porta da sa´ıda anal´ogica. Isso ocorre porque precisaremos ler o valor da tens˜ao que passa pelo fotoresistor. int fotores = 0; int led = 12; int som = 11; int leres; Agora definiremos as portas de sa´ıda e o in´ıcio do Serial. void setup() { Serial.begin(9600); pinMode(led, OUTPUT); pinMode (som, OUTPUT); } Agora come¸ca a fun¸c˜ao de loop. Captaremos as informa¸c˜oes sendo transmitidas atrav´es de analogRead(fotores), que s˜ao n´umeros inteiros, e armazenaremos na vari´avel leres. Em Serial.print(leres), estaremos verificando na janela do Serial Monitor o valor nu- m´erico de leres. A seguir, se leres for mais baixo que 400, ´e porque h´a uma sombra incidente sobre o fotore- sistor e, portanto, devemos tocar o som e acender a luz. Caso contr´ario, devemos apagar a luz e parar de tocar o som. Observe que esse valor pode alterar, dependendo da luminosidade do ambiente. Dessa forma, ´e interessante verificar os valores no Serial Monitor e observ´a-los, com o objetivo de encontrar um padr˜ao ambiente para sombra e editar o c´odigo. void loop() { leres = analogRead(fotores); Serial.println(leres); 42
- 44. if (leres <400){ digitalWrite(led, HIGH); tone(som,random(100,12000),1136); } else{ digitalWrite(led, LOW); noTone(som); } } Como podemos ver, enquanto fizermos uma sombra sobre o dispositivo, o programa to- car´a uma m´usica e deixar´a uma luz acesa. Uma observa¸c˜ao ´e de que, atrav´es da fun¸c˜ao random(100,12000), eu estou sorteando um valor de frequˆencia entre 100 e 12000. Dessa forma, teremos um valor diferente de frequˆencia para cada loop ocorrido. Caso estejam dis- pon´ıveis v´arios fotoresistores, seria mais interessante definir uma frequˆencia de som espec´ıfica para cada um. 43
- 45. 5.11 Exemplo 11 - Transmissor e Receptor RF Os transmissores de r´adio frequˆencia s˜ao abundantemente utilizados em projetos de controle e automa¸c˜ao e para envio de informa¸c˜oes. Muitas vezes nos perguntamos como conseguimos abrir um port˜ao autom´atico de garagem com um controle remoto e essa ´e uma das v´arias apli- ca¸c˜oes que encontramos para os componentes transmissores e receptores de RF. Neste projeto desenvolvido pelo PET-Tele produzimos uma das prov´aveis aplica¸c˜oes des- ses dispositivos. Atrav´es de duas placas de desenvolvimento Arduino, um transmissor RF (434MHz), um receptor RF (434MHz) e alguns resistores e LEDs elaboramos uma interface de controle a distˆancia com a ferramenta Serial Monitor da IDE do Arduino. O funcionamento do projeto consiste em enviarmos palavras via comunica¸c˜ao serial para o Arduino transmissor e a partir das palavras enviadas teremos diferentes respostas dadas pelo Arduino receptor. Planejamos como resposta o acionamento de LEDs, por´em poder´ıamos uti- lizar diversas outras interfaces como lˆampadas, rel´es e motores. A montagem do circuito ´e bem simples, por´em como temos uma quantidade maior de fios do que nas pr´aticas anteriores, ´e necess´aria aten¸c˜ao na montagem. Primeiramente ligamos a sa´ıda +5 V do arduino na trilha que usaremos como linha de alimenta¸c˜ao e fazemos respectivamente o mesmo com a entrada GND do Arduino em uma linha GND que usaremos na protoboard. Posteriormente conectamos os pinos 1, 6 e 7 do receptor e o pino 1 do transmissor na linha GND da protoboard. Ap´os, ligamos os pinos 4 e 5 do receptor e o pino 3 do transmissor na linha +5 V que fizemos na protoboard. Feito isso, os dispositivos estar˜ao devidamente alimentados e podemos conectar suas antenas. Ligamos ent˜ao um fio de cobre no pino 8 do receptor e outro fio no pino 4 do transmissor. Agora teremos que conectar os fios de comunica¸c˜ao entre os Arduinos e seus respectivos dispositivos. Para isso, conectamos o pino 2 do transmissor na entrada digital 6 do Arduino transmissor e o pino 2 do receptor na entrada digital 7 do Arduino receptor. O processo resulta nos circuitos das imagens abaixo: Agora conectaremos os LEDs no Arduino receptor. Ligamos ent˜ao um resistor de 330 Ω ao anodo de cada LED e os seus respectivos c´atodos `a linha de GND. Feito isso conectamos a sa´ıda digital 2 no resistor do LED amarelo, a sa´ıda 3 no resistor do LED verde e a sa´ıda 4 no resistor do LED vermelho. Resultando no circuito da figura abaixo: 44
- 46. (a) Receptor RF. (b) Transmissor RF. Figura 5.14: Receptor e Transmissor RF. (a) Receptor RF com leds. C´odigo Arduino Transmissor Primeiramente importamos a biblioteca VirtualWire.h para a comunica¸c˜ao entre o Arduino e o transmissor e definimos as vari´aveis que ser˜ao utilizadas: 45
- 47. #include <VirtualWire.h> char info[30]; int index = 0; char inChar; Agora definimos o pino digital 6 como sa´ıda e como transmissor de dados. Definimos tamb´em a sua taxa de transmiss˜ao de 2000 bps e a comunica¸c˜ao serial com 9600 baud. void setup() { pinMode(6,OUTPUT); Serial.begin(9600); vw_set_tx_pin(6); vw_set_ptt_inverted(true); vw_setup(2000); } Chegamos ent˜ao na parte final. Nessa etapa leremos cada valor char na vari´avel inChar e a armazenaremos no vetor info[index]. void loop() { if (Serial.available() > 0) { while (1) { inChar = Serial.read(); info[index] = inChar; index++; delay(2); Agora temos a fase de envio dos dados lidos na etapa anterior. Ap´os a palavra que foi digitada na interface Serial Monitor ser lida e armazenada no vetor info enviamos os dados armazenados no vetor pelo pino tx. if (Serial.available() <= 0) { index = 0; const char *msg = info; vw_send((uint8_t *)msg, strlen(msg)); vw_wait_tx(); memset( &info, 0, sizeof(info) ); break; } } } } C´odigo Arduino Receptor Como no Arduino Transmissor importaremos tamb´em o c´odigo do Arduino Receptor `a biblioteca VirtualWire.h. Definimos o vetor info, que armazenar´a os valores char, e os pinos que ligaremos os LEDs. 46
- 48. #include <VirtualWire.h> char info[30]; int amarelo = 2; int verde = 3; int vermelho = 4; Nessa etapa definimos os pinos de entrada e sa´ıda, a taxa de transmiss˜ao serial de 9600 baud, a taxa de recep¸c˜ao RF de 2000 bps e o seu respectivo pino 7. void setup() { pinMode(7,INPUT); pinMode(amarelo, OUTPUT); pinMode(verde, OUTPUT); pinMode(vermelho, OUTPUT); vw_set_rx_pin(7); vw_set_ptt_inverted(true); vw_setup(2000); vw_rx_start(); } Definidas as vari´aveis e as taxas de transmiss˜ao iniciamos a leitura dos dados recebidos. void loop() { uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; if (vw_get_message(buf, &buflen)) { int i; for (i = 0; i < buflen; i++) { info[i]=buf[i]; } Com os valores char armazenados no vetor info podemos agora utiliz´a-lo em uma estrutura de compara¸c˜oes para o acionamento dos LEDs conectados ao Arduino. if (String(info) == "amarelo on") { digitalWrite(amarelo, HIGH); } if (String(info) == "amarelo off") { digitalWrite(amarelo, LOW); } 47
- 49. if (String(info) == "verde on") { digitalWrite(verde, HIGH); } if (String(info) == "verde off") { digitalWrite(verde, LOW); } if (String(info) == "vermelho on") { digitalWrite(vermelho, HIGH); } if (String(info) == "vermelho off") { digitalWrite(vermelho, LOW); } if (String(info) == "acender tudo") { digitalWrite(amarelo, HIGH); digitalWrite(verde, HIGH); digitalWrite(vermelho, HIGH); } if (String(info) == "apagar tudo") { digitalWrite(amarelo, LOW); digitalWrite(verde, LOW); digitalWrite(vermelho, LOW); } memset( &info, 0, sizeof(info) ); } } 48
- 50. 5.12 Exemplo 12 - Intera¸c˜ao com Python e Linux Podemos utilizar o controle remoto pra diversas atividades. Uma funcionalidade poss´ıvel seria mudar os slides `a distˆancia durante uma apresenta¸c˜ao ou abrir algum programa ou arquivo espec´ıfico. Para que isso seja poss´ıvel, teremos que utilizar um programa em Python. Ou seja, mostra-se necess´ario possuir o interpretador Python na m´aquina. Al´em disso, ´e necess´ario que a m´aquina esteja usando Linux. Come¸caremos com o circuito, que ´e bastante simples. Ele s´o apresenta o receptor para o controle remoto e o Arduino. Figura 5.15: Circuito do Exemplo 12. 49
- 51. Primeiramente deve-se ter a biblioteca de infravermelho instalada na pasta correta, no Ar- duino Ubuntu. Para isso, digite no terminal: $ sudo cp -R NECIRrcv /usr/share/arduino/libraries Para identificar qual o c´odigo de cada bot˜ao do controle remoto usado, devemos programar o Arduino com o c´odigo exemplo presente na biblioteca NECIRrcv. Sendo alterado apenas a apre- senta¸c˜ao do c´odigo em hexadecimal para decimal, na linha Serial.println(ircode,HEX) ; para Serial.println(ircode) ; . Assim, temos o seguinte: #include <NECIRrcv.h> #define IRPIN 4 // pino que o detector Infravermelho est’{a} ligado NECIRrcv ir(IRPIN) ; void setup(){ Serial.begin(9600) ; Serial.println("NEC IR code reception") ; ir.begin() ; } void loop(){ unsigned long ircode ; while (ir.available()) { ircode = ir.read() ; Serial.print("got code:") ; Serial.println(ircode) ; } } Anotados os valores referentes aos bot˜oes que ir˜ao ser usados, o c´odigo referente aos bot˜oes ´e bastante simples. Come¸camos incluindo a biblioteca para utilizar o controle remoto, o que j´a foi ensinado nas pr´aticas anteriores. Definimos a porta anal´ogica 2 como a porta do receptor e criamos uma vari´avel valor para armazenar os valores enviados pelo controle. #include <NECIRrcv.h> NECIRrcv CR(2) ; unsigned long valor = 0; Agora, iniciaremos a comunica¸c˜ao Serial e a fun¸c˜ao CR, que ´e necess´aria para o uso do controle remoto. 50
- 52. void setup() { Serial.begin(9600); CR.begin() ; } Na fun¸c˜ao loop, leremos o valor recebido do controle remoto e armazenaremos na vari´avel valor (atrav´es da fun¸c˜ao CR.read() ). Agora, definimos dois bot˜oes para mudar os slides, o bot˜ao seta para cima e o bot˜ao seta para baixo, que correspondem aos c´odigos, respectivamente, 4111122176 e 4144545536 (´e importante ressaltar que esses valores podem variar dependendo do controle remoto). Nesse algoritmo, escreveremos na Serial o valor ‘1’ se apertarmos a seta para cima no controle e ‘2’ se apertarem a seta para baixo. void loop() { while (CR.available()) { valor= CR.read(); } if (valor == 4111122176) { Serial.println("1"); valor=0; } else if(valor == 4144545536) { Serial.println("2"); valor=0; } } Agora, teremos que escrever o programa em Python. Antes de mais nada, precisaremos utilizar uma biblioteca de Python chamada uinput. Ela possui fun¸c˜oes que interagem com o sistema operacional, podendo enviar valores para Linux que representam bot˜oes do teclado. Ou seja, faz com que o SO se comporte como se algum bot˜ao tivesse sido pressionado. Para instalarmos a biblioteca, devemos entrar no link e baixar o arquivo “python-uinput- 0.10.0.tar.gz”: 51
- 53. https://launchpad.net/python-uinput/+download Feito isso, devemos descompactar o arquivo escrevendo, no terminal: tar -vzxf python-uinput-0.10.0.tar.gz Agora, j´a possu´ımos o arquivo necess´ario para a instala¸c˜ao. Instalamos, no terminal, atrav´es de: python setup.py build python setup.py install Muitas vezes pode-se ter problemas com permiss˜oes de pastas para instalar a biblioteca do Python. No caso, trocando a linha de comando por: sudo python setup.py install pode resolver o problema. J´a temos a biblioteca instalada. Agora j´a podemos escrever o c´odigo em Python. Come¸ca- mos importando tudo que ´e necess´ario para o programa. Em seguida, devemos indicar quais teclas utilizaremos, o que ´e realizado atrav´es de: device = uinput.Device([uinput.KEY_LEFT, uinput.KEY_RIGHT]) Ou seja, utilizaremos as teclas de seta (direita e esquerda). Feito isso, definimos a porta do Serial. Normalmente, ´e a porta /dev/ttyACM0. Ap´os armazenarmos o valor lido da porta Serial (que definimos que escrever´ıamos ‘1’ ou ‘2’), podemos decidir qual bot˜ao simular no Linux. Caso lermos o valor ’1’, enviaremos o bot˜ao seta direita para o Linux, pois o Arduino detectou que foi apertado o bot˜ao seta para cima. Para o valor ’2’, enviaremos o bot˜ao seta esquerda. O nome do arquivo deve ter extens˜ao .py. Dessa forma, o c´odigo fica da seguinte maneira: #!/usr/bin/env python # -*- coding: utf-8 -*- import os,serial,commands,time # Importa bibliotecas import uinput # Importa biblioteca device = uinput.Device([uinput.KEY_LEFT, uinput.KEY_RIGHT]) porta = ’/dev/ttyACM0’ # Define porta do arduino while (True): # Repeti¸c~ao infinita 52
- 54. arduino = serial.Serial (porta,9600) # Cria conex~ao com arduino valor = arduino.read() if ( valor == ’1’): device.emit_click(uinput.KEY_RIGHT) elif ( valor == ’2’): device.emit_click(uinput.KEY_LEFT) Agora, basta executar o programa no terminal do Linux e deixar rodando. Para isso, digita- se: sudo python nomedoarquivo.py Dessa forma, toda vez que apertarmos os bot˜oes definidos, o Linux responder´a acionando os bot˜oes de seta definidos. Podemos tamb´em acionar outros bot˜oes do teclado e acionar progra- mas e arquivos espec´ıficos. Podemos pedir para executar o Firefox, por exemplo, atrav´es de: os.system(‘‘firefox& ") Enquanto podemos abrir um arquivo de m´usica, utilizando o player Rhythmbox atrav´es de (apenas um exemplo): os.system(‘‘rhythmbox /home/nomedousuario/Downloads/nomedamusica.mp3 & ") Pode-se abrir bloco de notas e outros tipos de arquivos. Basta especificar qual programa ser´a utilizado e o diret´orio do arquivo. 53
- 55. 5.13 Exemplo 13 - WEB Server Neste projeto elaboramos uma p´agina de controle HTML, com um Arduino Uno R3 e um Ethernet shield. No caso poder´ıamos utilizar diversas interfaces para contole, por´em, como exemplo, utilizamos um cooler 12 V e uma lˆampada fluorescente comum. O funcionamento do projeto consiste em controlar os componentes conectados a ele atrav´es de uma p´agina HTML que se encontra programada no Arduino. A p´agina possui bot˜oes em seu corpo que, quando acionados, enviam comandos para o Arduino e quando interpretados atuam sobre as intefaces conectadas. Figura 5.16: P´agina HTML. A montagem do projeto consiste em acoplarmos um shield Ethernet ao Arduino. E conec- tarmos as interfaces em seus respectivos pinos de controle. No caso conectamos o circuito de acoplamento do cooler ao pino 2 do Ethernet shield e o circuito de acoplamento da lˆampada ao pino 3 do Ethernet shield. O processo resulta na imagem abaixo: 5.13.1 Circuito de acoplamento do cooler Ao acionar a porta digital do Arduino teremos um n´ıvel de tens˜ao de 5 V, por´em para acionarmos elementos como o cooler 12 V utilizado no projeto teremos que utilizar um circuito de acoplamento como o da imagem abaixo: 54
- 56. Figura 5.17: Circuito Web Server. Figura 5.18: Circuito de acoplamento para cooler 12v. Trata-se de um simples transistor BD135 e um resistor de 1 kΩ conectado a sua base. Conec- tamos o coletor do transistor ao positivo da fonte 12 V, o emissor do transistor ao pino positivo do cooler e o pino negativo do cooler a trilha GND. O funcionamento do circuito consiste em quando alimentamos o resistor uma corrente flui na base do transistor e o mesmo passa a conduzir acionando o cooler. 5.13.2 Circuito de acoplamento para Lˆampada 110v Para acionarmos uma lˆampada com o Arduino teremos que utilizar outro circuito de aco- plamento. Visto que este tipo de carga trabalha com uma tens˜ao de alimenta¸c˜ao alternada de 110 V. Para isso utilizaremos um rel´e para o acionamento. O circuito ser´a o da imagem abaixo: Trata-se de um transistor BD135 funcionando como chave como no circuito de acoplamento para o cooler dado anteriormente. A diferen¸ca ´e que nesta configura¸c˜ao quando o acionamos o 55
- 57. Figura 5.19: Circuito de acoplamento para Lˆampada 110V. pino de sa´ıda do Arduino, o transistor passa a conduzir acionando um rel´e que quando fechado liga a lˆampada conectada ao mesmo. O diodo conectado em paralelo ao rel´e funciona como componente de prote¸c˜ao, j´a que quando desligamos o rel´e o mesmo passa a conduzir uma corrente instantˆanea muito alta que poderia queimar o transistor. O c´odigo: Abaixo explicaremos o c´odigo programado no Arduino. Iniciamos enunciando as bibliotecas utilizadas. No caso as bibliotecas SPI.h e Ethernet.h. Logo ap´os definimos os endere¸cos MAC, IP e a porta de comunica¸c˜ao utilizada. #include <SPI.h> #include <Ethernet.h> byte mac[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF }; byte ip[] = { 192, 168, 1, 177 }; Server server(180); Definiremos agora as vari´aveis e os pinos de controle utilizados. Ligaremos o cooler ao pino 3 e a lˆampada ao pino 4. int cooler = 3; int lampada = 4; char c = 0; char command[2] = "0"; Logo ap´os iniciaremos a comunica¸c˜ao Ethernet, e definiremos os pinos da lˆampada e do cooler como sa´ıda. void setup() { Ethernet.begin(mac, ip); server.begin(); 56
- 58. pinMode(lampada, OUTPUT); pinMode(cooler, OUTPUT); } Agora explicaremos a parte do c´odigo que estar´a em loop. Esta primeira parte ´e cons- tituida por fun¸c˜oes expec´ıficas da biblioteca Ethernet.h. Para maiores informa¸c˜oes acesse: http://arduino.cc/en/reference/ethernet void loop() { Client client = server.available(); if (client) { // an http request ends with a blank line boolean current_line_is_blank = true; while (client.connected()) { if (client.available()) { char c = client.read(); if (c == ’n’ && current_line_is_blank) { Primeiramente escrevemos o cabe¸calho da p´agina HTML gravada no Arduino: client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); Logo ap´os definimos a cor de fundo da p´agina: client.println("<body background-color:#040300>"); Criamos o t´ıtulo: client.println("<h1><center> Bem vindo ao PET-Tele!</h1><hr>"); Criaremos agora os bot˜oes de acionamento que ser˜ao utilizados. Nessa parte atribu´ımos os valores que ser˜ao enviados quando os bot˜oes forem acionados, o m´etodo de envio dos valores, o nome de cada bot˜ao e seus tamanhos. client.println("<form method=get name=form><center>"); client.println("<button name=b value=1 type=submit style=height:60px; width:150px>Cooler On</button>"); client.println("<button name=b value=2 type=submit style=height:60px; width:150px>Cooler Off</button>"); client.println("<br/><p>"); client.println("<button name=b value=3 type=submit style=height:60px; width:150px>Lampada On</button>"); client.println("<button name=b value=4 type=submit style=height:60px; width:150px>Lampada Off</button>"); 57
- 59. client.println("<br/><p>"); break; } if (c == ’n’) { current_line_is_first = false; current_line_is_blank = true; } else if (c != ’r’) { current_line_is_blank = false; } if (current_line_is_first && c == ’=’) { for (int i = 0; i < 1; i++) { c = client.read(); command[i] = c; } Agora criamos a etapa de controle. De acordo com cada valor enviado pela p´agina o Arduino responder´a de maneira diferente. Temos como exemplo o bot˜ao cooler on que quando acionado envia o valor 1 e nessa estrutura liga o cooler. Quando acionamos o bot˜ao cooler off o valor enviado ser´a 2 que tem o efeito de desligar o cooler. Esses valores foram definidos na etapa de constru¸c˜ao dos bot˜oes e poderiam ser quaisquer. if (!strcmp(command, "1")) { digitalWrite(cooler, HIGH); } else if (!strcmp(command, "2")) { digitalWrite(cooler, LOW); } if (!strcmp(command, "3")) { digitalWrite(lampada, HIGH); } else if (!strcmp(command, "4")) { digitalWrite(lampada, LOW); } } } } delay(1000); client.stop(); } Chegamos a parte final em que fechamos a p´agina. client.println("</body>"); } 58
- 60. 5.14 Exemplo 14 - Display de 7 segmentos I2C Este projeto surgiu da necessidade de um contador em projetos passados do grupo PET- Tele. Um dos projetos que exemplifica essa necessidade ´e conhecido como jogo Genius. O jogo consiste na memoriza¸c˜ao de luzes coloridas que s˜ao ligadas aleat´oriamente pelo Ar- duino. Na primeira rodada o Arduino pisca um dos quatro LEDs de cores diferentes. A partir disso, o jogador pressiona o bot˜ao correspondente ao LED que piscou. A cada rodada h´a o acr´escimo de uma piscada tornando o jogo cada vez mais dif´ıcil. O projeto Display de 7 seg- mentos I2C veio para nos auxiliar na contagem dessas rodadas. Para facilitar a conex˜ao dos fios `a placa Arduino, utilizaremos o protocolo de comunica- ¸c˜ao I2C. Dessa forma, ao inv´es de conectarmos cada segmento do Display de 7 segmentos `a uma porta do Arduino, conectaremos seus segmentos ao CI PCF8574AP e feita as conex˜oes de alimenta¸c˜ao do circuito conectaremos o pino SDA e SCL do CI aos pinos anal´ogicos 5 e 4 do Arduino. Dessa maneira deixaremos de utilizar diversas portas do Arduino e utilizaremos apenas duas para comunica¸c˜ao. O protocolo I2C possui 2 canais e foi originalmente desenvolvido pela Philips em meados de 1996. Nos dias de hoje, o protocolo encontra-se amplamente difundido e interconecta uma ampla gama de dispositivos eletrˆonicos. Dentre suas principais caracter´ısticas podemos citar: -Todo dispositivo possui um endere¸co ´unico no barramento. -Qualquer dispositivo conectado pode operar como transmissor ou receptor. -A taxa de transferˆencia m´axima ´e de 100 kbit/s no modo pad˜ao (standart), ou 400 kbit/s no modo r´apido (fastmode). -Possui duas vias de comunica¸c˜ao. A serial data (SDA) e a serial clock (SCL), ambas bi- direcionais, conectadas ao positivo da fonte de alimenta¸c˜ao atrav´es de um resistor de pull-up. Enquanto o barramento est´a livre, ambas as linhas ficam em n´ıvel l´ogico alto. Para montagem do projeto ´e necess´ario: 1 - Placa Arduino 1 - Display de 7 segmentos ˆAnodo comum 1 - CI PCF8574AP 2 - Resistor 10 kΩ 2 - Resistor 47 0Ω 1 - Capacitor cerˆamico de 100 nF A montagem procede nos sequintes passos: Primeiramente identificamos a pinagem do circuito integrado PCF8574AP. Encontramos na Figura 1 a imagem de identifica¸c˜ao desta pinagem. Feita a identifica¸c˜ao, encaixamos o CI na protoboard e ligamos os pinos de alimenta¸c˜ao e de endere¸camento (A0 ,A1 e A2).Para isso, ligamos, respectivamente, os pinos +5 V e GND do Arduino nas trilhas +5 V e GND do protoboard. Conectamos ent˜ao o pino VDD do PCF8574AP 59
- 61. Figura 5.20: Circuito integrado PCF8574AP. na trilha +5 V e o pino VSS a trilha GND do protoboard. No caso, como este ´e nosso primeiro e ´unico PCF8574AP no barramento, ligaremos os pinos A0, A1 e A2 na trilha GND gerando um endere¸co 000. Caso tiv´essemos outro CI, bastava ligar um dos pinos de endere¸camento na trilha +5 V gerando um novo endere¸co. Por exemplo, se lig´assemos A2 a trilha +5 V ter´ıamos o endere¸co 001. O processo resulta no circuito da Figura 2. Figura 5.21: Primeiro passo. Ap´os estas primeiras conex˜oes, identificamos a pinagem do Display 7 segmentos. A mesma encontra-se na Figura 3 e na tabela ao lado. 60
- 62. Figura 5.22: Display 7 segmentos. Pino Fun¸c˜ao 1 C´atodo E 2 C´atodo D 3 ˆAnodo comum 4 C´atodo C 5 C´atodo Ponto 6 C´atodo B 7 C´atodo A 8 ˆAnodo comum 9 C´atodo F 10 C´atodo G Tabela 5.1: Pinagem do display 7 segmentos. 61
- 63. Agora conectamos o resistor de 470 Ω ao pino 3 e `a trilha de +5 V e o segundo resistor de 470 Ω ao pino 7 e `a trilha de +5 V. Conectamos tamb´em os pinos de 1 a 10, exceto os pinos 3 e 4, aos pinos P0 a P7 do CI PCF8574AP. De modo que, o pino 1 do display fique ligado ao pino P0 do circuito integrado e assim progressivamente. O processo resulta na Figura 5.14. Figura 5.23: Segundo passo. Feito o passo anterior conectamos, agora, o pino SDA do CI ao pino anal´ogico 4 e o pino SDL ao pino anal´ogico 5 do Arduino. Figura 5.24: Terceiro passo. Finalizamos a montagem ligando um resistor de 10 KΩ `a trilha +5 V e ao pino SDA e o outro resistor de 10 KΩ tamb´em na trilha +5 V s´o que agora no pino SDL, formando assim os resistores de pull-up do protocolo I2C. Prosseguimos, agora, com a programa¸c˜ao do Arduino. Como exemplo, utilizaremos o se- guinte c´odigo que realiza uma contagem de 0 a 9 progressivamente e ap´os chegar a 9 retorna ao algarismo 0. Primeiramente, utilizaremos a biblioteca Wire.h e definiremos o endere¸co do PCF8574AP. Analizando o datasheet do CI, vemos que ele possui um endere¸co fixo interno (A6, A5, A4 e A3). Para sabermos qual endere¸co utilizar, temos a tabela verdade. 62
- 64. Figura 5.25: Quarto passo. Tabela verdade de endere¸cos Endere¸cos fixos Endere¸cos vari´aveis Endere¸co hexadecimal A6 A5 A4 A3 A2 A1 A0 0 1 1 1 0 0 0 38h 0 1 1 1 0 0 1 39h 0 1 1 1 0 1 0 3Ah 0 1 1 1 0 1 1 3Bh 0 1 1 1 1 0 0 3Ch 0 1 1 1 1 0 1 3Dh 0 1 1 1 1 1 0 3Eh 0 1 1 1 1 1 1 3Fh Logo nosso c´odigo iniciar´a com: #include <Wire.h> #define display 0x38 int time = 1000; void setup(){ Wire.begin(); } Para escrevermos no Display determinado algarismo, devemos enviar via c´odigo um de- terminado n´umero de bits que acionem os segmentos que formam este algarismo. Como, por exemplo, para formar o n´umero 0, precisamos acender os segmentos A, B, C, D, E e F. Para isso, escreveremos no barramento I2C a sequˆencia de bits 10001000. Estudando as conex˜oes podemos elaborar uma tabela com os algarismos poss´ıveis de serem representados e o respectivo conjunto de bits a serem enviados. 63
- 65. Algarismo Bits 0 10001000 1 11101011 2 01001100 3 01001001 4 00101011 5 00011001 6 00011000 7 11001011 8 00001000 9 00001011 Fazendo uso da tabela poderemos prosseguir com o nosso c´odigo. Utilizaremos a fun¸c˜ao Wire.beginTransmission(display); para inicializarmos a transmiss˜ao de dados. Enviamos a sequˆencia de bits com a fun¸c˜ao Wire.send(B10001000); e terminamos a transmiss˜ao com Wire.endTransmission(display);. Finalizamos o projeto com o c´odigo seguinte e lembramos que este foi escrito na IDE do Arduino 22. Atualiza¸c˜oes da IDE ou da biblioteca Wire.h podem modificar o c´odigo. void loop() { Wire.beginTransmission(display); Wire.send(B10001000); Wire.endTransmission(); delay(time); Wire.beginTransmission(display); Wire.send(B11101011); Wire.endTransmission(); delay(time); Wire.beginTransmission(display); Wire.send(B01001100); Wire.endTransmission(); delay(time); Wire.beginTransmission(display); Wire.send(B01001001); Wire.endTransmission(); delay(time); Wire.beginTransmission(display); Wire.send(B00101011); Wire.endTransmission(); delay(time); Wire.beginTransmission(display); Wire.send(B00011001); Wire.endTransmission(); delay(time); Wire.beginTransmission(display); Wire.send(B00011000); 64
- 67. 5.15 Exemplo 15 - LCD 16x2 I2C O LCD 16X2 ´e um dispositivo que junto ao Arduino nos permite graficar informa¸c˜oes di- versas. Dentre elas, podemos citar desde valores de sensores a algumas palavras. O nome deste projeto ´e LCD 16X2 I2C pois se trata de um display LCD de 16 caracteres por coluna com duas colunas. Ou seja, podemos graficar at´e 32 caracteres no nosso LCD 16X2. O I2C encontra-se presente no nome pois utilizaremos o protocolo de comunica¸c˜ao I2C para envio de dados entre o Arduino e o dispositivo. Para montagem do circuito precisaremos dos seguintes itens: 1 - Placa de desenvolvimento Arduino 1 - LCD 16X2 1 - Circuito integrado PCF8574AP 1 - Potenciˆometro de 10K Ω 2 - Resistores de 10k Ω Primeiramente, ´e preciso reconhecer as conex˜oes do nosso Display LCD com o CI PCF8574. Para isso teremos a Figura 1 e a Tabela 1. Figura 5.26: Display LCD 16x2. 66
- 68. Pino Ligamos a 1 Ground 2 +5 V 3 Potenciˆometro 10k Ω 4 Pino 11 PCF8574 5 GND 6 Pino 9 PCF8574 7 Pino 4 PCF8574 8 Pino 5 PCF8574 9 Pino 6 PCF8574 10 Pino 7 PCF8574 11 LED backlight +5 V 12 LED backlight GND Tabela 5.2: Conex˜oes ao circuito integrado PCF8574AP. 67
- 69. Podemos ver a pinagem no circuito integrado na Figura 2 abaixo. Figura 5.27: Circuito integrado PCF8574AP. Lembramos ao nosso leitor que vimos maiores informa¸c˜oes sobre o protocolo I2C em um projeto anterior com nome ”Display de 7 segmentos I2C“ e sugerimos que, para maior entedi- mento, seja feita a releitura deste projeto. Feita a releitura do projeto ”Display de 7 segmentos I2C“ podemos prosseguir com a mon- tagem do circuito. Primeiramente, encaixamos o CI na protoboard e ligamos os pinos de alimenta¸c˜ao e de endere¸camento (A0 ,A1 e A2). Para isso, ligamos, respectivamente, os pinos +5 V e GND do Arduino nas trilhas +5 V e GND do protoboard. Conectamos ent˜ao o pino VDD do PCF8574AP na trilha +5 V e o pino VSS a trilha GND do protoboard. No caso, como teremos um ´unico PCF8574AP no barramento ligaremos os pinos A0, A1 e A2 na trilha GND gerando um endere¸co 000. Caso tiv´essemos outro CI bastava ligar um dos pinos de endere¸amento a trilha +5 V gerando um novo endere¸co. Por exemplo, se lig´assemos A2 a trilha +5 V ter´ıamos o endere¸co 001. O processo resulta no circuito da Figura 3. Figura 5.28: Primeiro passo. Agora podemos encaixar nosso Display LCD 16X2 na protoboard e realizar as liga¸c˜oes ne- 68
- 70. cess´arias como visto na Tabela 1. Vale lembrar que neste circuito usaremos um potenciˆometro para ajuste de brilho do LCD. Para isso, ligaremos o primeiro pino do potenciˆometro a +5 V, o segundo pino ao pino 3 do PCF8574 e o ´ultimo pino ao GND. O processo nos resultar´a na Figura 4. Figura 5.29: Segundo passo. Feito o passo anterior, conectamos agora o pino SDA do CI ao pino anal´ogico 4 e o pino SDL ao pino anal´ogico 5 do Arduino. Finalizamos a montagem ligando um resistor de 10K Ω a trilha +5 V e ao pino SDA e o outro resistor de 10 KΩ tamb´em na trilha +5 V s´o que agora no pino SDL, formando assim os resistores de pull-up do protocolo I2C. Figura 5.30: Terceiro passo. Com a montagem do circuito conclu´ıda poderemos seguir com a programa¸c˜ao do Arduino. Utilizaremos em nosso c´odigo as bibliotecas Wire.h e LiquidCrystal-I2C.h. #include <Wire.h> #include <LiquidCrystal_I2C.h> 69
- 71. Na pr´oxima linha declaramos o endere¸co ao qual configuramos o CI PCF8574 no barramento I2C. LiquidCrystal_I2C lcd(0x38,16,2); Para sabermos o endere¸co configurado em nosso circuito podemos utilizar a tabela 2. Tabela verdade de endere¸cos Endere¸cos fixos Endere¸cos vari´aveis Endere¸co hexadecimal A6 A5 A4 A3 A2 A1 A0 0 1 1 1 0 0 0 38h 0 1 1 1 0 0 1 39h 0 1 1 1 0 1 0 3Ah 0 1 1 1 0 1 1 3Bh 0 1 1 1 1 0 0 3Ch 0 1 1 1 1 0 1 3Dh 0 1 1 1 1 1 0 3Eh 0 1 1 1 1 1 1 3Fh Agora inicializaremos o programa. void setup() { Inicializamos o nosso LCD no trecho seguinte. lcd.init(); Conclu´ımos enviando a mensagem. lcd.backlight(); lcd.print("PET-Tele!"); } void loop() { } 70
- 72. 5.16 Exemplo 16 - Emissor e Receptor infravermelho O emissor e o receptor infravermelho s˜ao um LED emissor de luz infravermelha e um tran- sistor receptor de luz infravermelha. O projeto tem in´umeras utilidadas, mas, como a principal, podemos citar um alarme de presen¸ca. Podemos colocar um emissor infravermelho no canto direito ou canto esquerdo de uma porta e o transistor receptor no canto oposto ao emissor. O funcionamento do circuito ´e bem simples. O Arduino monitora o valor de tens˜ao no pino coletor do transistor constantemente. Quando o valor de tens˜ao fica acima de um valor, o Arduino identifica este n´ıvel e aciona automaticamente o LED. Isso ocorre quando ao passar algum objeto em frente ao feixe de luz emitido pelo LED, o receptor infravermelho para de receber a luz e o n´ıvel de tens˜ao aumenta. A imagem abaixo ilustra o emissor e o receptor infravermelho. Emissor infravermelho Receptor infravermelho Tabela 5.3: Emissor e receptor infravermelho. Identificamos a pinagem do emissor como a de um LED comum. O pino maior ser´a positivo, ou seja, o nosso ˆanodo e o menor ser´a o negativo, no caso, o c´atodo. J´a no receptor identificamos o pino coletor por ser o maior pino do componente e o pino menor ser o pino emissor. Para montarmos o circuito utilizaremos o par emissor e receptor infravermelho, um resistor de 330 Ω e um resistor de 10 KΩ. Ligamos o resistor de 330 Ω na trilha +Vcc, o pino positivo do LED emissor no outro pino do resistor e o pino negativo do LED na trilha negativa do protoboard. Ap´os isso, ligamos o resistor de 10 KΩ na trilha positiva, o coletor do receptor na outra ponta do resistor e o emissor na trilha negativa. Para finalizar, ligamos a entrada anal´ogica A0 do Arduino entre o resistor de 10 KΩ e o coletor do receptor, ligamos a sa´ıda digital 3 do Arduino a um resistor de 330 Ω e, ap´os, ao positivo do LED. Ligamos tamb´em o negativo do mesmo na trilha negativa do protoboard. O circuito ficar´a como o da imagem: 71
- 73. Figura 5.31: Circuito emissor e receptor infravermelho. O c´odigo: Primeiramente, definimos as vari´aveis que ser˜ao utilizadas. No c´odigo temos, a vari´avel receptor que armazenar´a o pino onde o receptor est´a conectado. A vari´avel valor armazena o valor de tens˜ao lida pelo Arduino. E o LED armazena o pino onde est’a conectado o LED. int receptor = A0; int valor = 0; int led = 3; No void setup() vamos dizer que o pino do LED ´e de sa´ıda. Iniciaremos a comunica¸c˜ao serial e apagaremos o buffer da comunica¸c˜ao serial. void setup() { pinMode(led, OUTPUT); Serial.begin(9600); Serial.flush(); } No void loop() armazenaremos o valor lido na vari´avel valor. Em seguida printamos esse valor na Serial Monitor e faremos uma estrutura de compara¸c˜ao com if e else para ativarmos o LED caso o valor de tens˜ao passe do valor pr´e-definido. void loop() { valor=analogRead(receptor); Serial.println(valor); if(valor > 200) 72
- 75. 5.17 Exemplo 17 - Arduino stand-alone Neste projeto, montaremos um Arduino stand-alone que nada mais ´e que o ATmega328 em uma protoboard montado com o m´ınimo de componentes poss´ıveis para o seu funcionamento. O interessante neste projeto ´e que ele nos d´a suporte em projetos maiores, viabilizando trabalhar com mais de um microcontrolador ATmega sem que precisemos de mais de uma placa Arduino. Diminuindo assim, o custo do projeto e possibilitando confeccionarmos os nossos pr´oprios projetos sem gastarmos Arduinos neles. Para isso precisaremos dos seguintes componentes: 1 - ATmega328p (com bootloader do Arduino) 1 - Cristal oscilador de 16Mhz 2 - Capacitores cerˆamicos de 22pF 1 - Capacitor cerˆamico de 100 nF 1 - Resistor 330 Ω 1 - Resistor 10 KΩ 1 - Bot˜ao para Reset 1 - LED 1 - Placa Arduino sem o ATmega ou conversor USB/Serial Primeiramente, entenderemos a pinagem do microcontrolador ATmega328. Para isso, temos a tabela simplificada de sua pinagem logo abaixo: Figura 5.32: Microcontrolador ATmega328p. 74
- 76. Pino Leitura Pino Leitura 1 Reset 28 Analog input 5 2 Digital pin 0 (RX) 27 Analog input 4 3 Digital pin 1 (TX) 26 Analog input 3 4 Digital pin 2 25 Analog input 2 5 Digital pin 3 (PWM) 24 Analog input 1 6 Digital pin 4 23 Analog input 0 7 VCC 22 GND 8 GND 21 Analog Reference 9 Cristal 20 VCC 10 Cristal 19 Digital pin 13 11 Digital pin 5 (PWM) 18 Digital pin 12 12 Digital pin 6 (PWM) 17 Digital pin 11 (PWM) 13 Digital pin 7 16 Digital pin 10 (PWM) 14 Digital pin 8 15 Digital pin 9 (PWM) 75
- 77. Para montagem do circuito encaixaremos o ATmega328p no v˜ao central do protoboard, re- sultando na Figura 2. Figura 5.33: Etapa 1. Logo ap´os encaixaremos o cristal de 16Mhz nos pinos 9 e 10 do CI, um capacitor de 22pF li- gando ao pino 9 ao terra e o outro capacitor de 22pF ligando o pino 10 ao terra como na Figura 3. Figura 5.34: Etapa 2. Para a alimenta¸c˜ao do circuito podemos utilizar a sa´ıda 5 V e a GND da placa Arduino que usaremos de suporte. Para isso ligamos as sa´ıdas nas trilhas de alimenta¸c˜ao do protoboard. Feito isso, precirasemos ligar apenas os pinos +VCC (7 e 20) do Arduino a trilha +5 V e os pinos GND (8 e 22), do mesmo, a trilha GND do protoboard. Adicionamos tamb´em um capacitor de 100nF entre a trilha +5 V e GND do protoboard a fim de manter o circuito est´avel. Figura 5.35: Etapa 3. 76
- 78. Faremos agora o bo˜ao de Reset. Para isso, conectamos um pino do resistor de 10 KΩ a trilha +5 V e o outro pino ao pino de Reset do ATmega. Como o Reset funciona quando levamos o pino de Reset ao n´ıvel de 0 V precisaremos de um bot˜ao conectado com um dos seus conecto- res a terra e o outro ao pino Reset do microcontrolador. Assim, quando o bo˜ao for acionado faremos com que o nosso Arduino stand-alone entre em Reset. Figura 5.36: Etapa 4. Para finalizarmos a montagem conectamos os pinos TX(3) e RX(2) da nossa placa Arduino de suporte aos pinos TX(3) e RX(2) do microcontrolador. Conectamos tamb´em o pino Analog Reference a trilha de +5 V. Teremos como resultado final da montagem a Figura 5. Figura 5.37: Etapa 5. Com o circuito montado podemos iniciar a programa¸c˜ao do nosso Arduino stand-alone. Para tal, conectamos o cabo USB a placa do Arduino sem o microcontrolador. Feito isso, abrimos a IDE e selecionamos a placa cujo booatloader seja o que est´a instalado no microcontrolador. No caso, o nosso ATmega est´a com o booatloader do Arduino UNO. Logo selecionaremos a board Arduino UNO para realizarmos a programa¸c˜ao. Podemos agora realizar a programa¸c˜ao como feito de costume. Como exemplo, programa- remos o circuito BLINK cujo c´odigo ´e: void setup() { pinMode(13, OUTPUT); } 77
- 79. void loop() { digitalWrite(13, HIGH); // set the LED on delay(1000); // wait for a second digitalWrite(13, LOW); // set the LED off delay(1000); // wait for a second } Basta agora adicionarmos um resistor de 330 Ω ao pino 19 do microcontrolador (corresponde ao pino digital 13) e um LED conectado com o ˆanodo ao resistor e o c´atodo ao GND. O circuito final resulta na Figura 7. Figura 5.38: Etapa 6. 78
- 80. Cap´ıtulo 6 Referˆencias bibliogr´aficas Sites: http://www.sabereletr^onica.com.br/secoes/leitura/1307 Acessado em: 09/10/2010. http://arduino.cc/en/Reference/HomePage Acessado em: 09/10/2010. http://www.arduino.cc Acessado em: 09/10/2010. http://www.arduino.cc/en/Reference/AttachInterrupt Acessado em: 09/10/2010. http://projeto39.wordpress.com/o-arduino-duemilanove/ Acessado em: 09/10/2010. 79