Sumrio

Introduo.............................................................................................................................................2
O Programa...........................................................................................................................................3
A sintaxe..........................................................................................................................................3
Colocando a mo na massa...................................................................................................................3
A Protoboard....................................................................................................................................3
Projeto 1: Piscar um LED................................................................................................................4
Converso numrica........................................................................................................................5
lgebra booleana.............................................................................................................................6
Projeto 2: Semforo.........................................................................................................................7
A funo tone..................................................................................................................................9
Comunicao Serial............................................................................................................................10
Entradas e sadas analgicas...............................................................................................................10
Sadas analgicas...........................................................................................................................10
Entradas Analgicas.......................................................................................................................11
Projeto 3: Controle de luminosidade............................................................................................12
Motores DC....................................................................................................................................13
Projeto 4: Verificao de superfcie...............................................................................................13
Projetos extras....................................................................................................................................14
Projeto Extra 1: Semforo..............................................................................................................14
Projeto extra 2: Controle de luminosidade....................................................................................16
Proposta de implementao dos exerccios........................................................................................19
Bibliografia e materiais para consulta................................................................................................20

Alan Vitor Fonseca, Grupo Colmia

Minicurso Arduino, Junho 2012, Joinville-SC
Apoio - Daniel Scheidemantel Camargo e Brunno Prado
Centro de Cincias Tecnolgicas - Universidade do Estado de Santa Catarina

Introduo
Aprender eletrnica no uma tarefa simples, exige muito tempo e dedicao, conciliar
isso com o resto das nossas atividades dirias acaba sendo um desafio. Tudo isso junto com os
altos custos envolvidos acabam por inviabilizar a criao de dispositivos eletrnicos para muitas
pessoas.
Pensando nisso o co-fundador do Arduino Massimo Banzi
do Interaction Design Institute Ivrea na Itlia mobilizou um grupo
de pessoas a fim de criar uma soluo para este problema mais
barata e fcil de usar do que as j existentes na poca. Eles
decidiram fazer isso como um projeto de cdigo aberto, assim
todos poderiam ajudar e contribuir. Dessa ideia surgiu o Arduino.
Arduino uma plataforma open-source de prototipagem
com software e hardware flexvel e fcil de usar. De uma forma
menos tcnica, Arduino um conjunto de ferramentas que
possibilitam a criao de aparelhos eletrnicos onde a ideia fazer com que as pessoas possam
fazer o que quiser com eletrnica, no necessariamente aprendendo tudo antes. E como querer
fazer a sua camisa piscar, bem difcil fazer se voc quer aprender eletrnica, mas com o Arduino
voc pode fazer isso em poucos minutos.
Para entender melhor como funciona o Arduino vejamos o que um microcontrolador:

Microcontroladorbasicamenteumcircuitointegrado

contendo um microprocessador e todos os

perifricosessenciaisaoseufuncionamentocomo
memoriaeperifricosdeentradaesada.
Omicrocontroladorexecutaumprogramaespecifico
contendo instrues para que uma certa entrada
sejaprocessadagerandoumasadacorrespondente.
O Arduino torna fcil a criao de programas, a colocao do programa em um
microcontrolador (ATmega8, ATmega168, ATmega328, entre outros, dependendo da verso da
placa) e utilizao de suas portas de entrada ou sada.
Uma das grandes vantagens do Arduino o seu licenciamento sendo GPL para a IDE
Java, LGPL para as bibliotecas em C/C++ e Creative Commons Atribution Share-Alike para os
Esquemas da placa. Por isso qualquer pessoa pode contribuir criando uma biblioteca para
simplificar um processo complexo, tornando o mesmo extremamente simples, ou ento criando
verses da placa para algum objetivo especifico ou at mesmo criando exemplos e tutoriais. Isso
faz com que com uma simples pesquisa na internet traga inmeras solues para o que
precisamos.

O Programa
Vamos criar o nosso programa na prpria IDE do Arduino que usa uma linguagem baseada em
C/C++.

A sintaxe
Diferente da linguagem C original, a que usaremos ter algumas diferenas, por exemplo, aqui
no teremos uma funo principal - int main() - mas, basicamente teremos um programa da
forma:

void setup() usadaparafazeraconfigurao,comodizer

seumpinoseraentradaousadaeconfigurara
comunicaoserial.(executadoumaveznoiniciodoprograma)

void loop() usadaparaescreverarotinaaserexecutada

pelomicrocontrolador.
Este o esqueleto bsico de um programa, porem como em C podemos incluir bibliotecas
diferentes, declarar variveis globais, escrever outras funes fora das citadas acima, entre outras
funcionalidades.

Colocando a mo na massa
A Protoboard
A protoboard uma placa usada para criao de prottipos
ou circuitos experimentais onde os componentes e as
conexes podem variar sem a necessidade de solda. uma
matriz de contato, com furos tendo conexes verticais e
horizontais.
Ela funciona de forma que ao conectarmos um fio no
primeiro furo da coluna vertical, este estar em curto circuito
com qualquer outro fio conectado na coluna, ou seja,
como se conectssemos diretamente todos os fios da
coluna. Com as linhas horizontais o funcionamento o
mesmo.
Vamos agora escrever o nosso primeiro programa, mas como o Arduino no fica somente na tela
do PC, vamos criar um projeto bem simples e trabalhar em cima dele.

Projeto 1: Piscar um LED

Comeamos ento por um projeto clssico, Pisca LED , ou seja, queremos fazer um LED ficar
aceso por um tempo, depois apagar e assim por diante.
Para comear a escrever o programa precisamos saber em que pinos do Arduino estaro
conectados nossos componentes, nesse caso, somente o LED, ento vamos ao nosso circuito
eltrico:
Agora, com a parte do hardware j montada, vamos para o programa:

Como conectamos nosso LED no pino 10 do Arduino,

vamos declarar uma varivel do tipo inteiro para
guardarmos o numero do pinos em que o LED esta

int LED = 10;

(esta sera uma varivel global)

Agora vamos configurar o pino 10 como uma sada

void setup(){
pinMode(LED,OUTPUT);
}

Escrevemos agora a rotina para acender, esperar

algum tempo e depois apagar o LED
Declaramos a funo loop

void loop(){

Setamos o pino do LED para nvel logico alto

digitalWrite(LED, HIGH);

Esperamos um tempo (1000 ms)

delay(1000);

Setamos o pino do LED para nvel logico baixo

digitalWrite(LED, LOW);

Esperamos um tempo (1000 ms)

delay(1000);

Fechamos a funo loop

Vejamos o que as linhas mais relevantes significam:

pinMode(pino, modo)

Configura um pino especifico para se comportar como uma

entrada ou uma sada.

digitalWrite(pino, valor)

Escreve em um pino digital o valor logico Alto ou Baixo.

delay(tempo)

Pausa o programa durante um certo tempo especificado

em milisegundos.

Obs.: No prprio site do Arduino ( http://Arduino.cc/en/Reference/HomePage ) podemos

encontrar referencia sobre a linguagem utilizada, o site traz , entre outras coisas, referencia
sobre a sintaxe, operadores e funes.
Antes de irmos para o prximo projeto vamos ver algumas noes de converso numrica e
lgebra booleana.

Converso numrica
Apesar de que na IDE do Arduino as funes so feitas de forma a facilitar ao mximo o uso dos
nmeros e valores usados, ainda em alguns casos necessrio sabermos fazermos a converso
de base de um numero.
Mas o que a base de um numero? - De uma forma fcil, a base de um numero o total de
smbolos que usamos para escrev-lo, ou seja, a base em que mais usamos, a decimal, temos
10 smbolos(0 a 9) para escrever os nmeros que desejarmos e na base binaria 2 smbolos (0 e
1).
Como os microcontroladores e at mesmo os computadores, internamente s entendem
nmeros na base binaria, importante que saibamos escrever nmeros decimais em pelo menos
mais duas bases, a binaria e a hexadecimal, que tambm e largamente usada nesse meio.
Converso com base decimal para uma base qualquer: podemos fazer isso por meio das
divises sucessivas:

vamos converter o numero 4710(base 10) para a base hexadecimal(base 16)

47/16 = 2 , resto: 1510 = F16
2/16 = 0 , resto: 210 = 216

Dividimos o numero pela base em que queremos

transformar, no caso 16, at que o numero zere.

Dai tiramos o nosso numero na base hexadecimal 2F16.

Converso com base decimal para uma base qualquer: podemos fazer isso multiplicando cada
algarismo do numero por potencias de sua base elevadas a ordem significativa do numero, e
depois somando todos eles.

Vamos converter agora o numero 2F16 para a base decimal:

2F16 = 2*161 + 15*160 = 32 + 15 = 4710.

(visto que F16 = 1510).

Converso com base hexadecimal e binaria: essa converso fica fcil ao sabermos que, em
ordem, cada 4 algarismos binrios equivalem a um algarismo hexadecimal, e vice e versa.
Valor Numrico

8421

8421

Nmero Binrio

0010

0110

Nmero Hexadecimal

Portanto 2616 = 1001102

lgebra booleana
Antes de tudo devemos ter em mente:
Sistemasdigitaisusamalogicabinariadeformaqueoszeroseunssoos
nveislgicosnasentradasousadasdos
dispositivos,osquaistrabalhamcombaixastenses,
nocasodosmicrocontroladoresdaAtmel,5V(entre
1.85.5V),portantoumaentradanafaixaprxima
0Ventendidacomonvellogicobaixo(LOW),juma
faixaemtornode5Veentendidacomonvellogico
alto(HIGH).

Na lgebra booleana trabalhamos com esses nveis lgicos de

forma que 0 significa falso e 1, verdadeiro, e usamos algumas
operaes logicas:

OR

Ou

AND

NOT

No

NAND

No AND

AND
invertido(barrado)

NOR

No OR

OR
invertido(barrado)

XOR

Exclusive OR

Por exemplo, se tivermos como

entrada 3 sinais lgicos, verdadeiro,
falso e verdadeiro de novo, e
queremos realizar entre eles uma
operao logica AND, temos:
verdadeiro AND falso AND verdadeiro = falso

da mesma forma que:

1*0*1 = 0.

Assim como a operao OR: verdadeiro OR falso OR verdadeiro = verdadeiro 1+0+1 = 1.

Obs.: Observe que estamos executando uma operao logica soma e no uma soma como
estamos acostumados, portanto aqui 1+1 = 1.
A operao logica NOT inverte o nvel logico, ou seja o que era 0 vira 1 e vice e vera, e
representada por uma barra em cima da funo logica:
(verdadeiro OR falso)AND verdadeiro = (verdadeiro NAND falso)AND verdadeiro = falso (1+0)*1 = 1*1 = 0*1 = 0.

J a funo XOR e dada como: a b = ab + ba .

Projeto 2: Semforo
Nosso objetivo aqui fazer um programa que controle o transito de veculos em uma rua.
Teremos um semforo convencional de veculos
com os 3 passos mostrados ao lado. Sendo que
para efeito experimental deixaremos o sinal em
vermelho e verde por 5 segundos e amarelo por
1 segundo.
Tambm teremos um boto que ao pressionarmos
o sinal ira impedir a passagem de veculos, isso ,
caso o sinal esteja verde ele deve ir imediatamente
para amarelo e depois para vermelho.

Para isso usaremos algo chamado interrupo externa, que caso ocorra ela ira desviar o
programa de sua execuo atual, realizar alguma ao( uma funo no nosso caso), e depois
continuar o programa normalmente.
Uma interrupo pode ser atribuda a um pino do Arduino atravs da funo:
attachInterrupt(canal, funo, modo) , onde:
canal : indica o pino a ser usado pela interrupo canal 0 para o pino 2 e 1 para o pino 3.
funo : a funo que sera executada quando ocorre a interrupo.
modo : o tipo da interrupo, que pode ser:
LOW : interrupo dada quando o pino estiver com nvel logico baixo.
CHANGE : interrupo dada quando o pino muda de nvel logico.
RISING : interrupo dada quando o nvel logico vai de 0 para 1.
FALLING : interrupo dada quando o nvel logico vai de 1 para 0.
Vamos ento ao hardware, que sera montado com LEDs e um pushbutton:

O programa fica assim:

int passo = 1;

Varivel global para armazenar o passo atual.

int vermelho = 12, amarelo = 11, verde = 10;

Declarao dos LEDs usados conforme o

circuito.

int botao = 2;

Declarao do boto conforme o circuito.

void setup(){

Aqui temos a funo de configurao.

attachInterrupt(0, irVermelho,FALLING);

Vinculamos a funo irVermelho() com uma

interrupo externa na borda de descida do canal
0 ( no pino 2).

pinMode(botao,INPUT);

Configuramos o pino do boto como entrada.

pinMode(verde,OUTPUT);
pinMode(amarelo,OUTPUT);
pinMode(vermelho,OUTPUT);

Configuramos os pinos dos LEDs como sadas

digitais.

}
void irVermelho(){
p1();
passo = 1;
return;
}

Essa funo liga o LED vermelho e desliga os

outros, e retorna o passo para o primeiro*.

void p3(){
digitalWrite(vermelho,LOW);
digitalWrite(amarelo,HIGH);
digitalWrite(verde,LOW);
return;
}

Funo para colocar os LEDs no passo 3.

void p2(){
digitalWrite(vermelho,LOW);
digitalWrite(amarelo,LOW);
digitalWrite(verde,HIGH);
return;
}

Funo para colocar os LEDs no passo 2.

void p1(){
digitalWrite(vermelho,HIGH);
digitalWrite(amarelo,LOW);
digitalWrite(verde,LOW);
return;
}

Funo para colocar os LEDs no passo 1.

void loop(){

Funo loop aquela executada sempre que o

microcontrolador estiver alimentado.

if(passo == 1){
p1();
passo = 2;
delay(5000);
}

Aqui caso a varivel que guarda o passo atual

estiver em 1, executamos a funo que coloca os
LEDs no passo 1, ento mudamos a varivel
passo para indicar o novo passo e esperamos
5.000ms ou 5s.

if(passo == 2){
p2();
passo = 3;
delay(5000);
}

Faz o mesmo que o anterior porem para o

segundo passo.

if(passo == 3){
p3();
passo = 1;
delay(1000);
}

Executa o mesmo para o terceiro passo, porem

agora esperando apenas 1 segundo no sinal
amarelo.

}
* Em uma situao normal poderamos executar p1() e esperar 5s na prpria funo de
interrupo e depois ir direto para o passo 2, porem aqui a funo delay() no funciona. Nesse
caso como o tempo pequeno quase no vemos problema, porem quando o boto pressionado
o passo 1 fica por mais tempo ( o tempo que o programa j estava esperando no passo em que
estava mais o tempo de 5 segundos de p1() ). Como exerccio para o minicurso tente resolver este
problema.
No final da apostila temos mais um projeto com semforo mais prximo realidade com esse
problema resolvido.
Esta somente uma forma de fazer o programa, poderamos, por exemplo mudar os estados dos
LEDs na funo loop ao invs de criar funes separadas para isso. A logica de programao
muito importante nesses casos. Podemos resolver um problema aparentemente muito difcil de
uma forma fcil se usarmos a logica certa.
A funo tone
Esta funo gera uma onda quadrada em uma sada do Arduino com uma frequncia
especificada, vejamos como a funo:
tone(pino, frequncia, durao), onde a durao um argumento opcional.
Obs.: Nas placas do Arduino que usam o microcontrolador Atmega8, se usado, o argumento
durao causa um erro no programa. Podemos usar ento a funo noTone(pino).
Com essa funo podemos criar sons, sabendo a frequncia de uma nota musical por exemplo
podemos facilmente toc-la em um auto falante ou um piezo-eltrico ligado ao Arduino.

Comunicao Serial
Alm de funes prontas, o Arduino possui, na sua prpria IDE, o Serial Monitor que uma
interface para fazer o debug de programas, enviar e receber dados de forma serial.
Nas placas do Arduino que possuem conexo USB, essas podem ser usadas para fazer a
comunicao serial com um computador por exemplo. Vejamos ento como fazer isso.
Primeiro devemos fazer a configurao para a comunicao serial, atravs da funo:
Serial.begin(taxa) , onde:
taxa: a taxa de transmisso de dados, em bits por segundo(baud).
Agora podemos enviar dados com as funes Serial.print(), Serial.println() e Serial.write(), e ler os
dados recebidos com Serial.read() e Serial.peek().
Para checar se h dados recebidos podemos usar a funo Serial.available(), que retorna no
numero de bytes disponveis para leitura.

Entradas e sadas analgicas

Vejamos a seguir como podemos usar as entradas e sadas analgicas do Arduino.
Sadas analgicas
As sadas analgicas do Arduino usam PWM ou Modulao por largura de pulso, em portugus para variar a transferncia de potencia em um pino especifico.
Vejamos ento como funciona
o PWM. Quando temos o nivel
logico 1 em um pino do
Arduino e mudamos para 0,
temos um sinal como na figura
a esquerda:
J
quando
variamos
repetidamente a mudana de
nvel logico temos algo como
na figura a direita, o que
caracteriza uma onda quadrada, nesse caso se considerarmos um perodo, veremos que o pino
transferiu a metade da potencia que transmitiria se estivesse o tempo todo em nvel logico 1. O
PWM consiste em manipularmos o tempo, em cada perodo, que ficaremos em cada um dos
nveis lgicos.

10

Nesse caso, por exemplo temos 75 por cento de potencia transferida, porem no Arduino o perodo
dessas ondas muito baixo, fazendo com que a frequncia seja alta(aproximadamente 490 Hz),
portanto, se estivermos com um LED conectado a esse pino, no o veremos piscar, mas sim com
75% de sua luminosidade total. Em motores DC podemos controlar a velocidade do motor atravs
de PWM.
O Arduino possui alguns pinos que podem ser usados como PWM, e para isso usamos a funo:
analogWrite(pino, valor) , onde:
pino : pino de sada do PWM.
valor : valor entre 0 ( 0%) e 255 ( 100%) que determina a porcentagem em que o sinal
estar ativo.
Obs.: No e preciso declarar o pino como sada(usando pinMode()) para us-lo PWM.
Entradas Analgicas
Um pino de entrada analgica tem a funo de ler a tenso nele colocada e transformar esse valor
em um numero inteiro, no caso do Arduino teremos a preciso de 10 bits, ou seja 1024 valores
possveis, sendo 0 para 0V e 1023 para 5V.
A funo usada para leitura analgica no Arduino e a seguinte:
analogRead(pino) , onde pino indica o pino o qual sera feito a leitura.
Essa funo retorna um valor inteiro de 0 a 1023 correspondente a leitura feita.
Como funciona

No ensino mdio voc j deve ter estudado alguns circuitos com

resistores e viu que a corrente que circula em um circuito dada por
V
i=
, onde Re a resistncia equivalente do circuito, ou ento
Re
que a diferena de potencial V nos polos de um resistor V R =Ri .
Sabendo isso vejamos como ira ficar a tenso que iremos ler no Arduino:
V
V
=
Re
R1+R LDR
A tenso que estaremos lendo esta nos polos de R LDR , assim:
R LDR
V
V LDR = R LDR i = R LDR
ou V LDR =
V
R1 +R LDR
R1 +RLDR
Isso o que chamamos de divisor de tenso entre R1 e RLDR .
Assim, como R LDR varia conforme a luz que incide no LDR,
podemos variar V LDR
A corrente que circula no circuito : i =

Em um teste feito em uma sala qualquer quando o LDR era submetido

a muita luz obtivemos uma resistncia de 500, e sem luz de 90.000,

11

com esses dados a leitura V LDR mostrada no grfico a esquerda, e como o

Arduino possui um conversor analgico/digital de 10 bits, ou seja, vai do
decimal 0 ao 1023, podemos ver a leitura no grfico a direita.

Projeto 3: Controle de luminosidade

Para este projeto queremos controlar a luminosidade em um local, de forma que teremos um
boto que liga/desliga o sistema de iluminao. Quando o sistema estiver ligado usaremos um
LDR para verificar a luminosidade no local, quanto menor, a luz (LED) devera ter uma intensidade
maior.

Boto

Liga/Desliga o sistema de iluminao

LDR

Usado como sensor de luminosidade.

LED

Iluminao.

Esse projeto fica como exerccio para o minicurso. Uma resoluo possvel se encontra no final
desse material.

12

Motores DC
Quando falamos de motores eltricos e Arduino, comum ouvirmos falar nos Servomotores, o
qual temos uma livraria com varias funes prontas para trabalharmos com eles. Esses motores
so encontrados geralmente de forma que funcionam ligados diretamente aos pinos do Arduino.
Porem quando falamos de motores em geral, como o Arduino no fornece uma corrente e
voltagem muito altas, na maioria dos casos, teremos de fazer um circuito auxiliar para fazer o
motor funcionar e no trazer nenhum risco a placa, como queimar algum componente.
Esse circuito pode ser feito com transistores, como na figura abaixo:
Onde o ULN2003 um CI que
possui um conjunto de transistores
Darlington. Simplificadamente um
transistor um componente que
serve para amplificar o nosso
sinal, por exemplo, queremos usar
um motor de 12V e 0,2A, como o
Arduino s pode fornecer 5V e
alguns mA no teremos potencia o
suficiente para fazer o motor funcionar somente com o Arduino, ai que entra o transistor.
Um transistor possui 3 pinos, uma base, um coletor e um emissor, no caso do ULN2003, as
entradas(base) so barradas, ou seja, seu sinal invertido, portanto se o alimentarmos com 12V
(coletor), e tivermos nvel logico 0 na entrada ento teremos 12V na sada(emissor), e no caso de
nvel logico 1 na entrada teremos uma sada de 0V.
Projeto 4: Verificao de superfcie
Voc j deve ter visto aqueles robs que seguem uma linha no cho em
competies ou at mesmo em industrias. Veremos nesse projeto o
principio de uso desses robs.
Na figura a esquerda temos sensores e um emissor de luz infravermelha,
eles so usados, por exemplo, nas TVs, onde o controle remoto o
transmissor e um sensor junto a TV o receptor infravermelho.
Voc tambm j deve ter ouvido falar que a cor preta no reflete os raios de luz, isso tambm
ocorre com o infravermelho, quando temos um arranjo como na figura ao lado, os raios de luz
infravermelha saem do emissor, refletem no obstaculo e chegam at o receptor. Se esse objeto for
de cor preta a reflexo sera bem menor do que se ele for de cor branca, com isso podemos
distinguir, por exemplo, uma linha escura em um cho claro.
O objetivo desse projeto e distinguir um objeto branco de um preto atravs desses sensores.
Este projeto tambm fica como exerccio para o minicurso, uma possvel implementao esta no
final desse material.

13

Projetos extras
Projeto Extra 1: Semforo
Nosso objetivo aqui fazer um programa que controle o transito como no projeto 2 porem agora
teremos um grupo veicular e um de pedestres.
O semforo sera como mostrado abaixo, onde o sinal com 3 cores o veicular e o com 2 cores o
dos pedestres, e obedecendo as regras convencionais de um semforo.

2/3

Porem, alm disso, teremos um boto que quando pressionado reduzira o tempo que o pedestre
tem de esperar para passar.
Vamos ento ao hardware, que sera montado com LEDs e um pushbutton:

14

O programa fica assim:

int tempo = 0;

Varivel global para armazenar o tempo.

void reduzTempo(){
if(tempo >= 10 && tempo <=19)tempo = 19;
}

Funo para reduzir o tempo de espera caso

seja apertado o boto.

void setup(){

Aqui a nossa funo de configurao

attachInterrupt(0, reduzTempo,FALLING);

Vinculamos nossa funo reduzTempo() com

uma interrupo externa na borda de descida do
canal 0 ( no pino 2).

for(int i = 8 ; i <=12 ; i++){

pinMode(i,OUTPUT);
}
pinMode(4,INPUT);

Configuramos os pinos de 8 a 12(LEDs) como

sadas digitais.

}
void p3(){
digitalWrite(12,LOW);
digitalWrite(11,HIGH);
digitalWrite(10,LOW);
digitalWrite(9,LOW);
digitalWrite(8,HIGH);
return;
}

Configuramos o pino 4(pushbutton) como

entrada digital.
Funo para colocar os LEDs no passo 3.

// Vermelho
// Amarelo
// Verde
// Pedestre - Seguir
// Pedestre - Parar

void p2(){
digitalWrite(12,LOW);
digitalWrite(11,LOW);
digitalWrite(10,HIGH);
digitalWrite(9,LOW);
digitalWrite(8,HIGH);
return;
}

Funo para colocar os LEDs no passo 2.

void p1(){
digitalWrite(12,HIGH);
digitalWrite(11,LOW);
digitalWrite(10,LOW);
digitalWrite(9,HIGH);
digitalWrite(8,LOW);
return;
}

Funo para colocar os LEDs no passo 1.

15

void piscaVermelho(){
for(int x = 0; x<= 3;x++){
digitalWrite(8,HIGH);
delay(500);
digitalWrite(8,LOW);
delay(500);
}
return;
}

Funo para piscar 3 vezes o LED que indica

para os pedestres pararem.

void addTempo(){
delay(1000);
tempo++;
if(tempo > 22) tempo = 0;
return;
}

Funo usada para adicionar 1 segundo

(1000ms) na varivel que guarda o tempo.

void loop(){

Funo loop aquela executada sempre que o

microcontrolador estiver alimentado.

if(tempo == 0)p1();

Para o tempo entre 0 e 9 segundos colocamos

os sinais na posio 1.

if(tempo == 10){
digitalWrite(9,LOW);
piscaVermelho();
p2();
}
if(tempo == 20)p3();

Para o tempo entre 10 e 19 segundos,piscamos

o LED vermelho e depois mudamos os sinais
para a posio 2.

addTempo();

Executamos a funo para adicionar um

segundo a cada loop.

Para o tempo entre 20 e 22 segundos

colocamos os sinais na posio 3.

}
Esta somente uma forma de fazer o programa, poderamos, por exemplo mudar os estados dos
LEDs na funo loop ao invs de criar funes separadas para isso.
A logica de programao muito importante nesses casos, no programa acima, consideramos
que o tempo do ciclo no sair da faixa citada, e que no haja erro na sua adio, se pulssemos
do segundo 9 para o 11 , por exemplo, no teramos a mudana dos sinais para os segundo
estado.
Projeto extra 2: Controle de luminosidade
Para este projeto queremos controlar a luminosidade em um local, de forma que teremos 2
botes, um deles liga/desliga o sistema de iluminao, e o outro quando pressionado iniciara ou
adicionara tempo um timer que desligara a iluminao quando o tempo terminar.
Quando o sistema estiver ligado usaremos um LDR para verificar a luminosidade no local, quanto
menor, a luz (LED) devera ter uma intensidade maior.

16

Boto 1

Liga/Desliga o sistema de iluminao

Boto 2

Seta um timer para desligar o sistema.

LDR

Usado como sensor de luminosidade.

LED

Iluminao.

Circuito usado no projeto:

Cdigo fonte:

volatile float tempo = 0;

volatile float tempoDecorrido = 0;
volatile unsigned long tmpseg = 0;
volatile boolean ligado = false;
void timer(){
if(millis() > tmpseg+500){
tmpseg = millis();
tempo+=10000;
if(tempo >=50000){
tempo = 0;
tempoDecorrido = 0;
}

Inicializao das variveis:

Tempo do timer.
Tempo decorrido durante o timer.
Tempo de segurana contra mau contato.

Essa parte garante que o boto s de efeito

se apertado depois de 500 ms, isso previne
contra mal contato nos fios.
Aqui adicionamos 10s a varivel tempo a cada
vez que apertarmos o boto, e zeramos ela caso passe
de 5x pressionadas.

}
return;
}

17

void ligar(){
if(millis() > tmpseg+500){
tmpseg = millis();
ligado = !ligado;
tempo = 0;
tempoDecorrido = 0;
}
return;
}
void setup(){
attachInterrupt(0,timer,RISING);
attachInterrupt(1,ligar,FALLING);
}

Segue o mesmo da funo timer.

Aqui invertemos o valor da varivel
booleana ligado a cada vez que
pressionamos o boto, e zeramos as outras
variveis.

Pino 2 boto timer.

Pino 3 boto ligar.

void loop(){
if(ligado){
Faz a leitura do LDR.
int ldr = analogRead(4);
int luminosidade = map(ldr,320,830,0,255); Ajusta o valor da converso AD para o PWM.
Escreve o valor ajustado para a luminosidade do
analogWrite(11,luminosidade);
LED.
if(tempo > 0){
if(tempoDecorrido < tempo){
delay(100);
tempoDecorrido+=100;
}else{
ligado = false;
}
}
}else{
analogWrite(11,0);
}
}

Nessa parte verificamos se o timer esta

ativado ( tempo >0), caso isso ocorra:
Adicionamos 100 a varivel tempoDecorrido
para cada 100 milisegundos.
E caso tempoDecorriso seja maior que o
tempo do timer desligamos o sistema.
Caso a varivel ligado seja false
desligamos o sistema.

18

Proposta de implementao dos exerccios

Projeto 4:
Circuito usado no projeto:

Cdigo fonte:
int receptor = 2;
int claro = 550;
int escuro = 190;
String Cor = "",Verificar = "";
void setup(){
Serial.begin(9600);
}
void loop(){
int x = analogRead(receptor);
if(x > claro)Cor = "Objeto Claro";
if(x < escuro)Cor = "Objeto Escuro";
if(x < claro && x > escuro)
Cor = "Aproxime o Objeto";
if(Cor != Verificar){
Serial.println(Cor);
Verificar = Cor;
}
delay(500);

Ligamos o receptor IR no pino 2 (entrada analgica).

A leitura do receptor foi de 550+ para objetos claros,
E foi de 190- para objetos escuros.
Inicializamos as strings para enviar serialmente para o PC.
Inicializamos a comunicao serial na funo setup.

Lemos a entrada analgica ligada ao receptor.

Caso a leitura seja 550+ a string guardara Objeto Claro
Caso seja 190- guardara Objeto Escuro
Caso o valor esteja entre 190 e 550 pediremos para
aproximar um objeto.
Aqui verificamos se a string a ser enviada a mesma que a
anterior, caso sim evitamos a repetio da cor do objeto, caso
no enviamos serialmente a cor do objeto.
Esperamos um tempo para prevenir rudos na leitura.

19

Bibliografia e materiais para consulta

http://www.arduino.cc/

http://vimeo.com/31389230

http://www.tecmundo.com.br/android/10098-arduino-a-plataforma-open-source-quevai-automatizar-a-sua-vida.htm

20