Sumrio

1.

2.

Introduo ............................................................................................................................. 4
1.1.

Arduino ......................................................................................................................... 4

1.2.

O que realmente o Arduino?....................................................................................... 4

1.2.1.

A placa Arduino .................................................................................................... 5

1.2.2.

IDE Arduino .......................................................................................................... 6

Sadas Digitais ....................................................................................................................... 8

2.1.

2.1.1.

Programando ......................................................................................................... 8

2.1.2.

Grandezas Digitais e Analgicas ........................................................................... 9

2.1.3.

Entendendo o programa ...................................................................................... 10

2.2.

3.

Experincia 2 Usando a Protoboard ......................................................................... 16

2.2.1.

A Protoboard (Matriz de Contatos) ..................................................................... 16

2.2.2.

Separando os Ingredientes ................................................................................... 17

2.2.3.

Misturando os Ingredientes ................................................................................. 17

2.2.4.

Levando ao forno ................................................................................................ 17

2.2.5.

Entendendo o Hardware ...................................................................................... 17

2.2.6.

Cdigo de cores dos resistores ............................................................................ 19

Entradas Digitais ................................................................................................................. 20

3.1.

4.

Experincia 1 Blink .................................................................................................... 8

Experincia 3 Leitura de botes ............................................................................... 20

3.1.1.

Ingredientes ......................................................................................................... 20

3.1.2.

Misturando os ingredientes ................................................................................. 20

3.1.3.

Levando ao forno ................................................................................................ 20

3.1.4.

Preparando a cobertura ........................................................................................ 21

3.1.5.

Experimentando o prato ...................................................................................... 21

3.2.

Entendendo o Hardware .............................................................................................. 22

3.3.

Entendendo o Programa .............................................................................................. 23

Entrada Analgica ............................................................................................................... 26

4.1.

Experincia 4 Lendo uma entrada analgica ............................................................ 26

4.1.1.

Ingredientes ......................................................................................................... 26

4.1.2.

Misturando os ingredientes ................................................................................. 26

4.1.3.

Levando ao Forno................................................................................................ 26

4.1.4.

Preparando a cobertura ........................................................................................ 26

4.1.5.

Experimentando o prato ...................................................................................... 27

4.2.

Entendendo o Hardware .............................................................................................. 28

2

4.3.

5.

4.3.1.

Lendo da Entrada Analgica ............................................................................... 29

4.3.2.

Comunicao Serial............................................................................................. 29

PWM ................................................................................................................................... 31
5.1.

Usando a sada PWM .................................................................................................. 32

5.2.

Experincia 5 Led com controle de intensidade ....................................................... 32

5.2.1.

Ingredientes ......................................................................................................... 32

5.2.2.

Misturando os ingredientes ................................................................................. 32

5.2.3.

Levando ao forno ................................................................................................ 33

5.2.4.

Preparando a cobretura ........................................................................................ 33

5.2.5.

Experimentando o prato ...................................................................................... 33

5.3.
6.

Entendendo o programa .............................................................................................. 34

[EXTRA] Interrupo ......................................................................................................... 35

6.1.

7.

Entendendo o programa .............................................................................................. 29

Experincia 6 Implementando uma interrupo ....................................................... 35

6.1.1.

Ingredientes ......................................................................................................... 35

6.1.2.

Misturando os ingredientes ................................................................................. 35

6.1.3.

Levando ao forno ................................................................................................ 36

6.1.4.

Preparando a cobertura ........................................................................................ 36

6.1.5.

Experimentando o prato ...................................................................................... 37

6.2.

Entendendo o Hardware .............................................................................................. 37

6.3.

Entendendo o programa .............................................................................................. 37

Apndice - Tabela de consulta ............................................................................................ 39

1. Introduo
1.1.

Arduino

H no muito tempo, para se confeccionar um circuito interativo, era necessrio

fazer projetos do zero para uma aplicao especfica. Para se fazer pequenas alteraes
nas funcionalidades do circuito era necessrio um estudo crtico e bastante trabalho.
Com o advento dos microcontroladores, foi possvel que problemas que eram
tratados com hardware fossem tratados usando software de computadores. Dessa forma,
um mesmo circuito poderia tomar funes totalmente diferentes, reprogramando e
alterando alguns parmetros do programa.
Mas mesmo assim, trabalhar com microcontroladores no to trivial. Desta
forma, um grupo de pesquisadores italianos teve a ideia de fazer um dispositivo que
tornasse o seu uso simples e acessvel a qualquer um. O resultado foi o Arduino.
A filosofia fazer com que qualquer pessoa possa criar um projeto interativo, sem
a necessidade de ter que aprender sobre matrias complexas de engenharia. Dessa forma,
qualquer um pode ser um criador de tecnologia, no importando idade ou especialidade,
apenas algo presente em sobra no ser humano: a criatividade.

1.2.

O que realmente o Arduino?

No site oficial da Arduino, encontramos a seguinte definio (traduzida):

Arduino uma plataforma open-source de prototipagem eletrnica com
hardware e software flexveis e fceis de usar, destinado a artistas, designers, hobbistas
e qualquer pessoa interessada em criar objetos ou ambientes interativos.
Ou seja, o Arduino uma plataforma formada por dois componentes: A placa, que
o Hardware que usaremos para construir nossos projetos e a IDE Arduino, que o
Software onde escrevemos o que queremos que a placa faa.
A maior vantagem dessa plataforma de desenvolvimento sobre as demais a sua
facilidade de sua utilizao: pessoas que no so da rea tcnica podem, rapidamente,
aprender o bsico e criar seus prprios projetos em um intervalo de tempo relativamente
curto.

1.2.1. A placa Arduino

O hardware do Arduino simples, porm muito eficiente. Vamos analisar a partir
desse momento o hardware do Arduino UNO. Ele composto pelos seguintes blocos:

Figura 1 - Arduino Uno

1. Microcontrolador: O crebro do Arduino. Um computador inteiro dentro de um

pequeno chip. Este o dispositivo programvel que roda o cdigo que enviamos
placa. No mercado existem vrias opes de marcas e modelos de
microcontroladores. A Arduino optou pelo uso dos chips da ATmel, a linha
ATmega. O Arduino UNO usa o microcontrolador ATmega32.
2. Conector USB: Conecta o Arduino ao computador. por onde o computador e o
Arduino se comunicam com o auxlio de um cabo USB, alm de ser uma opo
de alimentao da placa.
3. Pinos de Entrada e Sada: Pinos que podem ser programados para agirem como
entradas ou sadas fazendo com que o Arduino interaja com o meio externo. O
Arduino UNO possui 14 portas digitais (I/O), 6 pinos de entrada analgica e 6
sadas analgicas (PWM).
4. Pinos de Alimentao: Fornecem diversos valores de tenso que podem ser
utilizados para energizar os componentes do seu projeto. Devem ser usados com
cuidado, para que no sejam forados a fornecer valores de corrente superiores ao
suportado pela placa.
5. Boto de Reset: Boto que reinicia a placa Arduino.
6. Conversor Serial-USB e LEDs TX/RX: Para que o computador e o
microcontrolador conversem, necessrio que exista um chip que traduza as
5

informaes vindas de um para o outro. Os LEDs TX e RX acendem quando o

Arduino est transmitindo e recebendo dados pela porta serial respectivamente.
7. Conector de Alimentao: Responsvel por receber a energia de alimentao
externa, que pode ter uma tenso de no mnimo 7 Volts e no mximo 20 Volts e
uma corrente mnima de 300mA. Recomendamos 9V, com um pino redondo de
2,1mm e centro positivo. Caso a placa tambm esteja sendo alimentada pelo cabo
USB, ele dar preferncia fonte externa automaticamente.
8. LED de Alimentao: Indica se a placa est energizada.
9. LED Interno: LED conectado ao pino digital 13.
1.2.2. IDE Arduino
Quando tratamos de software na plataforma Arduino, podemos referir-nos ao
ambiente de desenvolvimento integrado do Arduino e o programa desenvolvido por ns
para enviar para a nossa placa.
Uma das grandes vantagens dessa plataforma est no seu ambiente de
desenvolvimento, que usa uma linguagem baseada no C/C++, linguagem bem difundida,
usando uma estrutura simples. Mesmo pessoas sem conhecimento algum em
programao conseguem, com pouco estudo, elaborar programas rapidamente.
1.2.2.1.

Baixando e instalando a IDE Arduino

Acesse o site oficial da Arduino (www.arduino.cc). No site, clique
na aba Download.

Figura 2 - Site oficial Arduino

Na pgina Download, procure pela ltima verso do Arduino IDE.

No dia em que escrevo essa apostila, a ltima verso, ainda BETA, a
1.5.8.
Windows
Primeira Opo: baixar o instalador (Installer) que funciona como
qualquer outro instalador de programa.
6

Segunda Opo: Baixar todos os arquivos da IDE Arduino

compactados para Windows (ZIP file), nessa verso basta baixar e
descompactar na pasta que voc desejar, inclusive no seu pendriver ou HD
virtual. Eu costumo descompactar na rea de Trabalho.
Linux
Baixar todos os arquivos da IDE Arduino compactados para Linux
(32bit ou 64bit), nessa verso basta baixar e descompactar na pasta que
voc desejar, inclusive no seu pendriver ou HD virtual. Eu costumo
descompactar na rea de Trabalho.

1.2.2.2.

Entendendo a IDE Arduino

Em resumo, um program simples de se utilizar e de entender com
bibliotecas que podem ser facilmente encontradas na internet. As funes
da IDE do Arduino so basicamente trs: permitir o desenvolvimento do
software, de envi-lo placa para que possa ser executado e de se interagir
com a placa Arduino.

Figura 3 - IDE Arduino

2. Sadas Digitais
Experincia 1 Blink

2.1.

Vamos nossa primeira experincia. Nessa experincia iremos fazer o Arduino

piscar um LED de um em um segundo.
O Arduino UNO REV3 possui um LED na placa ligado porta digital 13. Com
isso, podemos testar o funcionamento de forma rpida e simples.
2.1.1.

Programando

Com seu Arduino conectado ao computador e devidamente configurado, abra o

menu File > Examples > 01. Basics > Blink. Uma nova janela deve ser aberta com um
texto escrito, esse o programa.
/* Blink - Pisca um led, de um em um segundo
Este cdigo exemplo de domnio publico. */
// Existe um LED conectado no pino 13 da maioria dos Arduinos
// Daremos um nome a este pino:
int led = 13;
// Esta funo "setup" roda uma vez quando a placa e ligada ou resetada
void setup() {
// Configura o pino do led (digital) como sada
pinMode(led, OUTPUT);
}
// Funo que se repete infinitamente quando a placa ligada
void loop() {
digitalWrite(led, HIGH); // Liga o LED (HIGH = nvel lgico alto)
delay(1000);
// Espera um segundo
digitalWrite(led, LOW); // Desliga o LED (LOW = nvel lgico baixo)
delay(1000);
// Espera um segundo
}

Agora clique em Upload para que o programa seja transferido para seu Arduino.
Se tudo foi feito corretamente, o led do pino 13, presente na placa do Arduino
UNO, ir piscar intermitentemente.

Figura 4 - Led conectado ao pino 13

2.1.2. Grandezas Digitais e Analgicas

Para entendermos o Arduino, necessrio que saibamos diferenciar uma grandeza
analgica de uma grandeza digital.

Digital x Analgico
Grandezas digitais so aquelas que no variam continuamente no tempo, mas sim
em saltos entre valores bem definidos. Um exemplo so os relgios digitais: apesar do
tempo em si variar continuamente, o visor do relgio mostra o tempo em saltos de um em
um segundo. Um relgio desse tipo nunca mostrar 12,5 segundos, pois, para ele, s
existem 12 e 13 segundos. Qualquer valor intermedirio no est definido.
Grandezas analgicas so aquelas que, ao contrrio das grandezas digitais, variam
continuamente dentro de uma faixa de valores. O velocmetro de um carro, por exemplo,
pode ser considerado analgico, pois o ponteiro gira continuamente conforme o
automvel acelera ou freia. Se o ponteiro girasse em saltos, o velocmetro seria
considerado digital.
Outra analogia interessante pode ser feita comparando uma escada com uma
rampa: enquanto uma rampa sobe de forma contnua, assumindo todos os valores de altura
entre a base e o topo, a escada sobe em saltos, com apenas alguns valores de altura
definidos entre a base e o topo. A escada representa, portanto, uma grandeza digital,
enquanto a rampa representa uma grandeza analgica. A quantidade de degraus em uma
escada define quais posies podemos escolher. Por exemplo se uma escada tem um
degrau em 1,00 m de altura do solo e o prximo est a 1,50 m ns no podemos ocultar a
posio 1,38 m do solo porque no existe um degrau l. Quanto mais degraus adicionamos
em um intervalo de altura menor mais perto da rampa nos aproximamos.

Figura 5 - Sinal analgico

Os circuitos e equipamentos eltricos ditos digitais trabalham com apenas dois

valores de tenso definidos:

Um nvel lgico alto, que no caso do Arduino 5V;

Um nvel lgico baixo, que no caso do Arduino 0V.

Na prtica existem faixas de valores prximos a esses nmeros em que o circuito

digital entende como nvel alto ou baixo. Tambm existe uma faixa intermediria no
definida que pode gerar resultados inesperados e que, portanto, deve ser evitada.
Os circuitos e equipamentos eltricos ditos analgicos trabalham com uma faixa
de valores chamada de range:

No Arduino essa faixa de valores (range) vai de 0V a 5V.

As placas Arduino possuem uma clara diviso entre os pinos de entrada e sada
digitais/analgicos, porm em algumas placas como o modelo Arduino Uno qualquer
pino pode ser utilizado como entrada ou sada digital.
2.1.3. Entendendo o programa

Pensando como um computador

Computadores e microcontroladores no possuem uma inteligncia tal como um

ser humano ou um animal. Eles so projetados para resolver problemas a partir de uma
lista de tarefas, semelhante a uma receita de bolo.
Dessa forma, para resolver um problema em um computador, tal como fazemos
para resolver problemas cotidianos, fazer um bolo, por exemplo, devemos descrever a
soluo de uma forma clara e precisa, por meio de passos a serem seguidos at que se
atinja um resultado esperado.
O nome dessa lista de passos o algoritmo. Um algoritmo um conjunto finito de
regras que fornece uma sequncia de operaes a fim de solucionar um problema.
Veja o exemplo da seguinte receita de bolo:

10

// RECEITA DE BOLO COMUM DE OVOS

INCIO
Passo 1: Separar os ingredientes
Ingredientes:
2 ovos;
3 xcaras de farinha de trigo;
1 e colher de fermento;
xcara de leite.
1/2 xcaras de acar;
250g de manteiga;

Modo de preparo:
Passo 2: Aquea o forno a 180 graus;
Passo 3: Quebre os ovos e separe as claras da gema;
Passo 4: Bata as claras em neve e as deixe separadas;
Passo 5: Em uma vasilha, bata o acar, a manteiga e as gemas;
Passo 6: Misture a farinha e o leite;
Passo 7: Bata bem, at ficar bem homogneo;
Passo 8: Acrescente o fermento;
Passo 9: Adicione as claras em neve e mexa cuidadosamente;
Passo 10: Unte uma forma com manteiga e farinha de trigo.
Passo 11: Coloque a massa na forma untada
Passo 12: Leve ao forno mdio para assar por aproximadamente 35 minutos ou at que, ao
espetar um palito, esse saia seco;
Passo 13: Aps assado, desligue o forno e deixe o bolo esfriar;
Passo 11: Desenforme e saboreie.
FIM

receita se assemelha
Passo Essa
11: Desenforme
e saboreie.aos

algoritmos que iremos fazer ao longo dessa apostila.

FIMdefine o que iremos usar, e depois diz passo a passo o que devemos fazer.
Ele

Veja que no podemos fazer o passo 4 sem antes fazer o passo 3, nem o passo 11
sem os passos anteriores. Existe uma ordem a ser seguida para que o bolo fique conforme
esperado.
No diferente para o computador, ele precisa de ordens organizadas e coerentes,
que ao final da receita resulte na soluo de seu problema.
Alm da ordem de passos, voc deve falar em uma lngua que o computador
entenda, no adianta uma receita em grego para um brasileiro. Para o nosso caso usamos
uma linguagem baseada em C++. Tal como qualquer lngua, ela possui suas regras de
como us-la adequadamente.
Despois de traduzido o algoritmo para a linguagem do Arduino, teremos o cdigofonte, cdigo de programa ou simplesmente programa. Muitos gostam de chamar tambm
de sketch.

11

Sempre faa comentrios

Sempre quando escrevemos um programa importante que deixemos notas

explicando o seu uso, tanto para que outras pessoas entendam quanto para ns mesmo.
Muitas vezes fazemos um programa para uma determinada funo achando que
s iremos us-lo uma nica vez. Quando, depois de muito tempo, nos damos conta de que
precisaremos dele novamente, j tarde. Por mais que voc seja bom de memria, muito
difcil lembrar de tudo que voc pensou durante a confeco de seu programa.
Dessa forma, quando no deixamos notas explicando como o programa funciona,
perdemos tempo relendo todo o programa para entend-lo. Alm disso, caso algum pea
seu programa emprestado, se o mesmo no estiver comentado, ser de difcil
entendimento.
Por isso, temos cdigos especiais na IDE Arduino para comentrios. Lembre-se
de sempre us-las.
Em resumo, um comentrio um texto que ser desconsiderado na hora de rodar
o programa, ele no tem valor nenhum para o Arduino. Na IDE Arduino, os comentrios
ficam em tonalidade cinza.
Existem duas formas de fazer comentrios, podemos comentar um bloco de texto
ou podemos apenas comentar uma linha.
Para comentar um bloco de texto devemos definir o comentrio indicando o incio
usando /* (barra e asterisco) e o final usando */ (asterisco e barra).
/* Blink - Pisca um led, de um em um segundo
Este cdigo exemplo de domnio publico. */

Para comentar uma linha, definimos apenas o incio do comentrio, usando //

(duas barras). No necessrio que se comece um comentrio de linha no incio da linha.
// Existe um LED conectado no pino 13 da maioria dos Arduinos
digitalWrite(led, HIGH); // Liga o LED (HIGH = nvel lgico alto)

s vezes, quando queremos testar o programa ignorando uma linha do cdigo,

simplesmente comentamos ela. Dessa forma ela no ser lida na hora de carregar o
programa para o Arduino.
//digitalWrite(led, HIGH); Essa linha no lida pelo Arduino

12

Variveis

Quando programamos, precisamos continuamente guardar uma informao para

usarmos posteriormente. Por exemplo, caso voc queira somar dois nmeros, voc ter
que armazenar o resultado em algum lugar. Esse lugar reservado se chama varivel.
Neste exemplo o lugar seria x, que recebe o resultado da soma 1+1.
x = 1 + 1; //x recebe 2, que o resultado da soma 1+1

Imagine que a memria do seu Arduino possui muitas gavetas, quando queremos
usar uma, devemos dar um nome a ela e falar qual tipo de contedo ela guardar. Cada
gaveta uma varivel.
Ao declarar uma varivel devemos definir qual tipo de contedo ela receber. Para
isso voc deve saber com qual tipo de dado mexer. Em nosso exemplo, x deve ser uma
varivel do tipo int, isso porque ela receber um valor inteiro.
int x; //x uma varivel do tipo inteiro
x = 1 + 1; //x recebe 2, que o resultado da soma 1+1

No Apndice 1 voc pode conferir uma tabela com os principais tipos de variveis
e suas particularidades.
Ao criar uma varivel, interessante que ela tenha um nome associado informao que ela
armazena. No exemplo anterior, no lugar x poderamos ter usado o nome soma ou resultado.

Em nosso programa declaramos a varivel do tipo int chamada led que armazena
o nmero 13, que o nmero da porta onde est localizado o LED que pisca com a
execuo do programa. Dessa forma, quando escrevemos led em nosso programa, ele
corresponder a 13, que est escrito dentro da varivel.
int led = 13;

Funo

Muitas vezes desempenhamos um conjunto de instrues. Por exemplo: pense em

uma situao cotidiana, constantemente precisamos saber qual a hora. Suponhamos que
para isso voc desempenhe o seguinte conjunto de instrues.
Pegue seu celular;
Ligue a tela;
Leia qual a hora;
Desligue a tela;
Guarde o celular;

Para facilitar nossa vida, podemos chamar esse conjunto de instrues por um
nome para que sempre que quisermos saber a hora, no seja preciso descrever todas as
instrues necessrias para isso.
13

void lerHora(){
Pegue seu celular;
Ligue a tela;
Leia qual a hora;
Desligue a tela;
Guarde o celular;
}

Em resumo, funo um bloco de tarefas a serem executadas pelo programa

quando solicitada. Agora, quando escrevemos Lerhora(), estamos chamando o conjunto
de instrues correspondentes.
lerHora(); // Excuta o conjunto de instrues da funo lerHora

Toda funo deve ter um nome e um tipo. No caso das duas, o tipo void e o
nome setup e loop, respectivamente. Para sabermos onde comea e termina o bloco de
tarefas de uma funo usamos { para indicar o incio e } para indicar o final.

Funo setup() e funo loop()

No Arduino existem duas funes que so fundamentais ao programa, a setup e a

loop. Elas so chamadas automaticamente pelo microcontrolador quando ligado:
A funo setup executada apenas uma vez ao ligar ou reiniciar sua placa
Arduino. Nela colocamos todas as instrues que queremos que o Arduino execute apenas
uma vez. Geralmente, nela que definimos parmetros iniciais de nosso programa.
// Esta rotina "setup" roda uma vez quando a placa e ligada ou reiniciada
void setup() {
// Configura o pino do led (digital) como sada
pinMode(led, OUTPUT); // led corresponde a 13
}

Nesse exemplo, o nico comando contido na funo setup o pinMode, esse

comando muito importante no uso das entradas e sadas digitais do Arduino. Com esse
comando definimos se o pino uma entrada (input) ou uma sada (output). No nosso caso
queremos que o pino 13 seja uma sada.
pinMode(led, OUTPUT); // led corresponde 13

A funo loop executada ciclicamente pelo Arduino. Dessa forma, ao chegar na

ltima linha, ele volta para a primeira. Sendo assim, nessa funo escrevemos as funes
que queremos que ocorram continuamente.

14

// Funo que repete infinitamente quando a placa ligada

void loop() {
digitalWrite(led, HIGH); // Liga o LED (HIGH = nivel lgico alto)
delay(1000);
// Espera um segundo
digitalWrite(led, LOW); // Desliga o LED (LOW = nivel lgico baixo)
delay(1000);
// Espera um segundo
}

Na funo loop temos dois comandos. O primeiro comando, o digitalWrite, define

qual o estado de sada, LOW para nvel lgico baixo (0V) e HIGH para nvel lgico alto
(5V) de uma determinada porta, no nosso caso a porta 13 representada pela varivel led.
Veja que devemos definir o pino que queremos mexer para depois escolher o estado para
o qual ele deve ir.
digitalWrite(led, HIGH); // Liga o LED (HIGH = nivel lgico alto)

O segundo o delay. O comando delay cria uma pausa no algoritmo pelo tempo
determinado em milissegundos (1 segundo igual a 1000 milissegundos).
delay(1000);

// Espera um segundo

Ponto e virgula e chave

Como j explicado, o microcontrolador do Arduino l o cdigo linha por linha,

executando instruo por instruo. Dessa forma, quando escrevemos uma instruo,
devemos informar onde ela comea e acaba. Para isso serve o ponto e vrgula (;).
digitalWrite(led, HIGH); // Liga o LED (HIGH = nivel lgico alto)
delay(1000);
// Espera um segundo

Veja o exemplo do delay(1000), essa instruo pede para que o Arduino pare por
1 segundo. Para que o Arduino leia a instruo, entenda e execute, necessrio que ele
saiba onde ela comea e onde ela termina. Nesse caso, ela comea logo aps o ponto e
vrgula da linha anterior e acaba no ponto e vrgula da prpria linha.
Para blocos de instrues usamos chaves, aberta { para comear e fechada }
para terminar. Um exemplo de bloco de instrues so as funes.
void setup() {
pinMode(led, OUTPUT);
}

Nesse exemplo o bloco de funo setup comea no colchete aberto e termina no

colchete fechado. J a instruo pinMode comea no colchete aberto e termina no ponto
e vrgula.

15

2.2.

Experincia 2 Usando a Protoboard

Essa experincia ser semelhante anterior com a diferena de que aprenderemos

a usar um equipamento fundamental para quem quer realizar experincias com circuitos
eletrnicos, a Protoboard.
2.2.1. A Protoboard (Matriz de Contatos)
Quando trabalhamos com circuitos eltricos em laboratrio, muitas vezes usamos
a protoboard. Ele tem o intuito de simplificar o processo de estudo e pesquisa de circuitos
eltricos e eletrnicos. Sendo uma matriz de contatos reutilizvel, evitamos a necessidade
de confeccionar uma placa de circuito impresso e possibilita a fcil alterao do circuito,
deixando ele flexvel.

Figura 6 - Circuito impresso

Nas extremidades podemos notar dois barramentos de contatos paralelos ao

formato da protoboard. No centro temos barramentos perpendiculares com um pequeno
espaamento no meio. A imagem a seguir mostra como est ordenado os barramentos.

Figura 7 - Protoboard 400 furos

Usando o Arduino, continuamente teremos que montar circuitos com LEDs,

sensores, entre outros. Dessa forma, o uso de protoboards ser comum no seu dia-a-dia
como um desenvolvedor.

16

2.2.2. Separando os Ingredientes

Para essa experincia precisaremos dos seguintes componentes:

1 LED 5mm
1 Resistor 470
Fios Jumpers
1 Protoboard

2.2.3. Misturando os Ingredientes

Agora vamos conectar os componentes do projeto. Para isso monte seu circuito
conforme a figura a seguir.
Garanta que seu Arduino esteja desligado durante a montagem e que o seu LED
esteja conectado corretamente, com a perna mais longa (Anodo) conectado ao resistor e
a perna menor (catodo) ao GND.

Figura 8 - Circuito da experincia 2

2.2.4. Levando ao forno

Agora temos que carregar o programa no Arduino. Caso voc tenha carregado
outro programa ou ainda no fez o exemplo 1 e seu Arduino ainda no esteja com o
programa Blink, volte ao item 2.1.1 e faa o mesmo procedimento da experincia 1, j
que usaremos o mesmo programa.
Depois que o Arduino estiver ligado com o programa carregado, o LED deve
comear a piscar intermitentemente.
2.2.5. Entendendo o Hardware
Quando configuramos um pino como sada digital, tal como a porta 13 nessa
experincia, ele pode fornecer 0 ou 5 V fazendo com que ele drene ou fornea corrente
do circuito controlado. O valor mximo dessa corrente varia de placa para placa, mas, em
geral, de 30mA. Essa corrente mais do que suficiente para ligar um LED de alto-brilho
e alguns sensores, porm no suficiente para ligar a maioria dos rels e motores. Caso
17

uma corrente maior que o limite, passe por um pino, este poder ser danificado.
Ao usar um pino como sada tenha cuidado para no drenar mais que o mximo suportado.
Caso uma corrente maior que o limite passe por um pino, este poder ser danificado. No
Arduino esse valor costuma ser de 30mA.

Quando precisamos de correntes maiores usamos dispositivos que, a partir da

tenso de sada do pino digital do Arduino, no chaveados para conduzir ou no conduzir
a corrente vinda de uma fonte externa. Exemplo:
Transistor (EXTRA);
Rel;
Ponte H (EXTRA)

Resistor

Componente eletrnico que dificulta a passagem de corrente eltrica. Esta

dificuldade de passagem de corrente denominada resistncia e medida em ohms.
Cada componente e equipamento eletrnico possui uma corrente mxima de
funcionamento, por isso, o uso de resistores essencial. Ele ter o papel de limitar a
corrente mxima do circuito.

Figura 9 - Resistor

LEDs

O LED (Diodo Emissor de Luz) um componente que, quando uma corrente

eltrica passa por ele em um determinado sentido, passa a emitir luz. Por isso o LED
tem que estar no sentido correto no circuito para no ter riscos de queim-lo.

Figura 10 - LED

18

2.2.6. Cdigo de cores dos resistores

19

3. Entradas Digitais
No captulo anterior vimos como controlar uma sada digital e fizemos um LED
piscar intermitentemente. No entanto, na vida real, um sistema interativo trabalha
processando entradas e atuando atravs de sadas.
Nesse capitulo, iremos aprender como acender um LED (sada) a partir de um
boto (entrada).

3.1.

Experincia 3 Leitura de botes

3.1.1. Ingredientes

Boto de presso
Resistor 1k
1 LED 5mm
1 Resistor 470
Fios Jumpers
Protoboard

3.1.2. Misturando os ingredientes

Agora vamos conectar os componentes do projeto. Para isso monte seu circuito
conforme a figura a seguir.
Garanta que seu Arduino esteja desligado durante a montagem, e que o seu LED
esteja conectado corretamente, com a perna mais longa (Anodo) conectado ao resistor e
a perna menor (catodo) ao GND.

Figura 11 - Circuito da Experincia 3

3.1.3. Levando ao forno

Conecte seu Arduino ao computador e abra a IDE Arduino. No menu Tools,
certifique que a porta serial (serial port) est selecionada e se a placa configurada a que
voc est usando (board).
20

3.1.4. Preparando a cobertura

Agora temos que dar vida ao Arduino. Para isso, dentro da IDE Arduino: abra o
menu File > Examples > 01. Basics > Button.
Uma nova janela deve ser aberta com o programa conforme apresentado a seguir.
Clique em Upload para que o programa seja transferido para seu Arduino.

/*
Button
Utiliza um boto de presso, conectado ao pino 2, para ligar e
desligar um LED conectado ao pino digital 13.
*/
// Determinamos constantes para os nmeros dos pinos utilizados
const int buttonPin = 2;
// Numero do pino do boto de presso
const int ledPin = 13;
// Numero do pino do led
// Variaveis
int buttonState = 0;

// Varivel para leitura do estado do boto

// Executa uma vez ao ligar ou reiniciar a placa

void setup() {
pinMode(ledPin, OUTPUT); //Inicializa o pino do LED como sada (OUTPUT)
pinMode(buttonPin, INPUT); // Inicializa o pin do boto como entrada
(INPUT)
}
// Executa infinitamente quando liga a placa
void loop() {
// L o estado do botao (HIGH -> +5V -> boto press.) (LOW -> 0V)
buttonState = digitalRead(buttonPin);
// Testa se o boto est pressionado
// Se sim, o estado do boto e alto (HIGH)
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
// Liga o LED
}
// Seno (Botao nao pressionado)
else {
digitalWrite(ledPin, LOW);
// Desliga o LED
}
}

3.1.5. Experimentando o prato

Caso tenha ocorrido tudo como esperado, quando voc apertar o boto acender o
LED embutido na placa, ou o LED da protoboard caso tenha optado por manter o LED
da experincia 2. Quando voc soltar o boto, o LED apagar.

21

3.2.

Entendendo o Hardware

Quando configuramos um pino como entrada digital ele apresentar uma

caracterstica chamada alta impedncia. Isso significa que uma pequena corrente
consegue fazer com que seu estado mude. Podemos usar essa configurao, por exemplo,
para ler botes, fotodiodos entre outros. E a partir do estado lido ou das mudanas desses
estados, concluir o que est acontecendo no mundo externo e ento tomar aes baseadas
nessas medidas.
Caso o pino seja configurado como entrada mas no estiver conectado a nada, ele poder
alterar seu estado aleatoriamente por ser afetado pelo rudo eltrico do ambiente.

Para evitar esse problema, podemos utilizar um resistor de pull up ou pull down. Esses
resistores faro com que a tenso em nossa entrada esteja bem definida quando o mesmo
no estiver conectado a nada. As figuras mostram trs ligaes de um boto a um pino do
microcontrolador configurado como entrada digital. Para cada caso temos:

Entrada sem pull up ou pull down: O estado do pino no estar bem definido
fazendo com que este esteja suscetvel a rudo.

Figura 12 - Entrada sem pull-down ou pull-up

Pull-down: Neste caso, devido presena do resistor de pull-down, seu estado

est bem definido e ele enxergar GND, consequentemente definindo seu estado
como baixo.

Figura 13 - Entrada com pull-down

Pull-up: Neste caso, devido presena do resistor de pull-up, seu estado est
bem definido e ele enxergar +5 V, consequentemente definindo seu estado
como alto.
22

Figura 14 - Entrada com pull-up

Na experincia usamos um pul-down. Dessa forma, o pino 2 tem 0V normalmente.

S alterando quando algum pressionar o boto, passando para 5V enquanto pressionado.

3.3.

Entendendo o Programa

Boa parte desse programa semelhante ao usado na experincia 1 e 2. Focaremos

agora na parte no apresentada anteriormente.

Constantes
Quando definimos uma varivel que no ir mudar ao longo da execuo do

programa, definimos ela como uma constante.

Um exemplo de varivel constante o nmero dos pinos do Arduino que
usaremos, j que eles no mudaro ao longo do programa.
// Determinamos constantes para os nmeros dos pinos utilizados
const int buttonPin = 2;
// Numero do pino do boto de presso
const int ledPin = 13;
// Numero do pino do led

Comando pinMode
Na funo setup podemos encontrar o comando pinMode. Como j dito na

experincia 1, esse comando muito importante no uso das entradas e sadas digitais do
Arduino. Ele responsvel por definir se um pino uma entrada (INPUT) ou uma sada
(OUTPUT).
void setup() {
pinMode(ledPin, OUTPUT); //Inicializa o pino do LED como saida (OUTPUT)
pinMode(buttonPin, INPUT); // Inicializa o pin do botao como entrada
(INPUT)
}

Na primeira linha da funo setup de nosso exemplo, temos o pino 13, definido
pela constante ledpin, sendo configurado como sada digital.
pinMode(ledPin, OUTPUT); //Inicializa o pino do LED como sada (OUTPUT)

Na segunda linha temos o pino 2, definido pela constante buttonPin, sendo

configurado como uma entrada digital.
pinMode(buttonPin, INPUT); // Inicializa o pin do botao como entrada (INPUT)

23

Comando digitalRead
Na funo Loop temos o programa que rodar ciclicamente em nosso Arduino.

Como desejamos acender um LED a partir de um boto, primeiramente devemos ler o

seu estado. Para isso, usamos o comando digitalRead, que retorna o valor de estado de
uma entrada digital passada como parmetro.
Nesse comando, caso a tenso na entrada digital seja 5V, ele retornar 1, caso seja
0V, retornar 0.
Para usar esse resultado devemos armazen-lo em algum lugar, nada melhor que
uma varivel para isso. No exemplo, armazenaremos o valor do boto na varivel
buttonState
No nosso caso, quando o boto estiver pressionado, teremos 5V na porta 2, ou
seja, 1 na varivel buttonState.
// Comando que l o estado do botao (HIGH -> +5V -> botao press.) (LOW ->
0V)
buttonState = digitalRead(buttonPin);

Bloco IF
Ao resolver um problema, constantemente teremos que tomar decises lgicas a

partir dos resultados coletados. Vamos voltar receita do bolo. Caso esse bolo seja para
uma festa de aniversrio, interessante que se faa uma cobertura, caso contrrio,
podemos deixar o bolo sem cobertura. Veja como ficaria o algoritmo para essa situao:
Funo bolo(){
Faa o bolo;
Se o bolo de aniversrio {
Faa uma cobertura;
}Seno
No faa uma cobertura
}
fim

Veja que usamos um parmetro para decidir se iremos ou no executar uma

atividade. Veja o fluxograma a seguir.
um bolo de
Aniversrio?

Se for: Faa
Cobertura

Se no for :
No Faa
cobertura

Dessa forma, em nosso exemplo, caso buttonState seja igual a 1 (boto

pressionado), devemos acender o LED, caso contrrio, devemos apaga-lo.

24

buttonState ==1?

Se for: Ligue o
LED

Se no for :
Desligue o LED

No programa fica assim:

// Testa se o boto est pressionado
// Se sim, o estado do boto e alto (HIGH)
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
// Liga o LED
}
// Seno (Botao nao pressionado)
else {
digitalWrite(ledPin, LOW);
// Desliga o LED
}

Operadores Lgicos
Para usar blocos lgicos, tal como o bloco IF, usaremos operadores lgicos. Os

operadores lgicos, junto aos parmetros, so responsveis por criar as condies de

execuo de um bloco lgico.
Voltando ao bolo, caso voc no tenha leite condensado, ser invivel fazer uma
cobertura de brigadeiro. Dessa forma, o nmero de latas de leite condensado disponveis
deve ser maior ou igual a 1 latas para que seja vivel fazer essa cobertura.
Vejamos o fluxograma resultante:
N de latas de leite
condensado >= 1?

Se for: Faa a
cobertura de
brigadeiro

Se no for : no
faa a cobertura
de bigadeiro

A condio maior ou igual um operador lgico, veja os possveis operadores

lgicos na tabela a seguir.
Operadores de Comparao
==
Igual
!=
Diferente
<
Menor
>
Maior
<=
Menor e igual
>=
Maior e igual

25

4. Entrada Analgica
O uso de entradas digitais limita nossas possibilidades, visto que o mundo
analgico. Sendo assim, a leitura de valores analgicos muitas vezes se faz necessrio.
Nesse captulo, aprenderemos como podemos usar as entradas analgicas das
placas Arduino.

4.1.

Experincia 4 Lendo uma entrada analgica

4.1.1. Ingredientes

Potencimetro
Fios Jumpers
Protoboard

4.1.2. Misturando os ingredientes

Agora vamos conectar os componentes do projeto. Para isso, monte seu circuito
conforme a figura a seguir e garanta que seu Arduino esteja desligado durante a
montagem.

Figura 15 - Circuito da experincia 4

4.1.3. Levando ao Forno

Conecte seu Arduino ao computador e abra a IDE Arduino. No menu Tools,
certifique de que a porta serial (serial port) est selecionada e que a placa configurada a
que voc est usando (board).
4.1.4. Preparando a cobertura
Agora vamos implementao do programa. Nesse algoritmo iremos fazer
diferente. Voc ter que escrever o programa tal como escrito abaixo, isso fundamental
26

para que voc acostume com a linguagem e a estrutura da programao do Arduino.

Para isso, dentro da IDE Arduino: abra o menu File > New ou aperte ctrl+N.
Uma nova janela, em branco deve ser aberta.
Agora devemos dar um nome ao nosso sketch (esse o nome dado aos programas
no Arduino), mas podemos chamar de arquivo de programa ou cdigo. Dessa forma,
dentro da IDE Arduino: Abra o menu File e clique em Save. Uma nova janela ser aberta
onde voc escolher onde salvar seu programa e qual ser seu nome. Para facilitar a
identificao, d o nome de programa_entradaanologica.
Com o seu programa salvo, escreva nele o cdigo conforme escrito abaixo.
// Esta funo "setup" roda uma vez quando a placa e ligada ou resetada
unsigned int valorLido;
void setup() {
Serial.begin(9600); //Inicia porta serial e define a velocidade de transmisso
}
// Funo que se repete infinitamente quando a placa ligada
void loop() {
valorLido = analogRead(A0);
Serial.println(valorLido);
delay(1000); // Espera um segundo

Depois de escrever o cdigo, Clique em Upload para que o programa seja

transferido para seu Arduino.
4.1.5. Experimentando o prato
Para essa experincia, voc ter que abrir o serial Monitor que ser melhor
explicado mais frente. Para isso, o serial monitor pode ser aberto pelo cone mostrado
na figura a seguir.

Figura 16 - Monitor serial

Caso tenha ocorrido tudo como esperado, conforme voc varie a resistncia do
27

potencimetro, girando seu eixo, aparecer no serial monitor um valor de 0 1023.

4.2.

Entendendo o Hardware

Potencimetro e trimpot

Potencimetros e trimpot so resistores variveis e ajustveis, e por isso so

usados para controle analgico de funcionalidades de alguns aparelhos eletrnicos, tal
como o volume de um aparelho de som.
Eles costumam possuir trs pernas. Dois so ligados s extremidades da
resistncia (A e B) e a terceira a um cursor que anda de ponta a ponta da resistncia
(C).Dessa forma, podemos usar o resistor entre A e C ou B e C.

Figura 17 - Potencimetro

Divisor de tenso

Quando temos n resistncia associadas em srie temos o nome de divisor de

tenso. Em um circuito divisor de tenso, temos uma queda de tenso em cada resistncia
igual ao produto da resistncia com a corrente do circuito.
Como a corrente do circuito calculada pela diviso da tenso em cima de todos
os resistores dividido pela soma dos resistores, teremos a tenso em cima de um resistor
igual a resistncia desse resistor vezes a tenso total dividida pela soma dos resistores.
O exemplo a seguir mostra como funciona o clculo o para dois resistores.

Figura 18 - Divisor de tenso

28

Quando usamos um potencimetro, podemos usar a propriedade do divisor de

tenso. Sabemos que a tenso total e a resistncia total so fixas. Dessa forma, o divisor
de tenso vai variar com a resistncia A0 e GND.

4.3.

Entendendo o programa

4.3.1. Lendo da Entrada Analgica

A leitura da entrada analgica feita com a funo analogRead, que recebe como
parmetro o pino analgico a ser lido e retorna o valor digital que representa a tenso no
pino. Como o conversor analgico-digital do Arduino possui uma resoluo de 10 bits, o
intervalo de tenso de referncia, que no nosso caso 5 V, ser dividido em 1024 pedaos
(2^10) e o valor retornado pela funo ser o valor discreto mais prximo da tenso no
pino.
unsigned int valorLido = analogRead(A0);

O cdigo acima l o valor analgico de tenso no pino A0 e guarda o valor digital

na varivel valorLido. Supondo que o pino est com uma tenso de 2V, o valor retornado
pela converso ser:
2 x 1024 / 5 = 409,6
O resultado deve ser inteiro para que nosso conversor consiga represent-lo, logo
o valor 410 ser escolhido por ser o degrau mais prximo. Esse valor representa a tenso
2,001953125, inserindo um erro de 0,001953125 em nossa medida devido a limitao de
nossa resoluo.
O uso do comando unsigned na declarao da varivel informa que usaremos apenas nmeros
positivos para essa varivel.

4.3.2. Comunicao Serial

A comunicao serial amplamente utilizada para comunicar o Arduino com
outros dispositivos como mdulos ZigBee, Bluetooth, entre outros. A comunicao com
o computador possvel atravs do conversor serial USB presente nas placas. A biblioteca
padro do Arduino possui algumas funcionalidades para a comunicao serial de modo a
facilitar a utilizao desta funo.

Serial Monitor

A possibilidade de visualizar na tela do computador os dados coletados e

processados pelo Arduino fundamental, visto que um forma rpida e prtica de
visualizar esses dados. Para isso, usamos o Serial Monitor.
29

O Serial Monitor disponibiliza uma interface grfica que facilita a comunicao

entre o Arduino e um computador. Aps selecionarmos a porta serial adequada, o serial
monitor pode ser aberto pelo cone no canto superior direito da janela, onde representado
por uma lupa.
Serial.begin(9600); //Inicia porta serial e define a velocidade de transmisso

Enviando Dados

Na maioria das vezes, o envio de dados pela porta serial pode ser feito atravs das
funes print e println. A funo print imprime os dados na serial utilizando o cdigo
ASCII. Essa funo recebe dois parmetros e retorna a quantidade de bytes que foram
escritos.
Serial.print(var); // Imprime a varivel var
Serial.print(ol);// Imprime o texto ol

O parmetro var recebe o valor a ser impresso. A funo sobrecarregada de

modo a ser capaz de receber qualquer tipo padro (char, int, long, float etc).
Quando o texto estiver entre aspas, isso simboliza que voc deseja imprimir um
texto. Caso contrrio, voc deseja imprimir uma varivel.
A funo println imprime o valor desejado semelhantemente a funo print, porm
imprime na sequncia os caracteres \r e \n de modo que crie uma nova linha.

30

5. PWM
PWM (Pulse Width Modulation Modulao por Largura de Pulso) uma tcnica
para obter resultados analgicos por meios digitais. Essa tcnica consiste na gerao de
uma onda quadrada em uma frequncia muita alta em que pode ser controlada a
porcentagem do tempo em que a onda permanece em nvel lgico alto. Esse tempo
chamado de Duty Cycle e sua alterao provoca mudana no valor mdio da onda, indo
desde 0V (0% de Duty Cycle) a 5V (100% de Duty Cycle) no caso do Arduino.

Figura 19 - Sinal PWM

O duty cycle a razo do tempo em que o sinal permanece na tenso mxima (5V
no Arduino) sobre o tempo total de oscilao, como est ilustrado na figura abaixo:

Figura 20 - Duty cycle

Duty Cycle (%) = (x/x+y)*100% = (x/T)*100%

Vmdio = Vmax*Duty Cycle(%)
O valor do Duty Cycle usado pelo Arduino um inteiro armazenado em 8 bits, de
forma que seu valor vai de 0 (0%) a 255 (100%).
31

5.1.

Usando a sada PWM

Para escrever um sinal na sada PWM utiliza-se a funo analogWrite, que recebe

como parmetros o pino PWM e o valor do duty cycle, respectivamente. Esse ltimo
parmetro guardado em 8 bits, de modo que esse valor deve estar entre 0 (0% de duty
cycle) e 255 (100% de duty cycle).
analogWrite(9,127);//Escreve no pino 9 um sinal PWM com 50% de duty cycle
//(50% de 255=127)
analogWrite(10,64);//Escreve no pino 10 um sinal PWM com 25% de duty cycle
//(25% de 255=64)

Variando o duty cycle altera-se tambm o valor mdio da onda, de modo que o
efeito prtico obtido com o PWM em algumas aplicaes um sinal com amplitude
constante e de valor igual ao valor mdio da onda. Isso permite que se possa, por exemplo,
controlar a intensidade do brilho de um LED, ou a velocidade de um motor de corrente
contnua.

5.2.

Experincia 5 Led com controle de intensidade

5.2.1. Ingredientes

Potencimetro
LED 5mm
Resistor 470
Fios Jumpers
Protoboard

5.2.2. Misturando os ingredientes

Agora vamos conectar os componentes do projeto. Para isso, monte seu circuito
conforme a figura a seguir.
Garanta que seu Arduino esteja desligado durante a montagem e que o seu LED
esteja conectado corretamente, com a perna mais longa (Anodo) conectado ao resistor e
a perna menor (catodo) ao GND.

32

Figura 21 - Circuito da experincia 5

5.2.3. Levando ao forno

Conecte seu Arduino ao computador e abra a IDE Arduino. No menu Tools,
certifique que a porta serial (serial port) est selecionada e se a placa configurada a que
voc est usando (board).
5.2.4. Preparando a cobertura
Crie um programa (sketch) e salve com o nome de programa_pwm. Com o seu
programa salvo, escreva nele o cdigo conforme escrito abaixo.
// Daremos um nome ao pino que est conectado o LED
int led = 13;
unsigned int valorLido;
unsigned int pwm;
// Esta funo "setup" roda uma vez quando a placa e ligada ou resetada
void setup() {
pinMode(led, OUTPUT); // Configura o pino do led (digital) como sada
}
// Funo que se repete infinitamente quando a placa ligada
void loop() {
valorLido = analogRead(A0); // valor entre 0 e 1024
pwm = map(valorLido, 0, 1023, 0, 255); // Mudana de escala
analogWrite(led,pwm);//Escreve no led um sinal PWM proporcional ao valorLido
}

Depois de escrever o cdigo, Clique em Upload para que o programa seja

transferido para seu Arduino.
5.2.5. Experimentando o prato
Se tudo der certo, conforme girarmos o potencimetro, a intensidade de luz
emitida pelo LED diminuir ou aumentar.
33

5.3.

Entendendo o programa
Como j explicado no incio do captulo, o PWM pode ser usado para simular uma

sada analgica. Variando um sinal de sada de PWM de 0 a 255, estamos variando o Duty
Cycle, que por sua vez, resulta numa sada de 0V a 5V.
Como a intensidade de luz no LED est diretamente ligada quantidade de
corrente que passa por ele e essa corrente proporcional a tenso do resistor em srie com
o LED, conforme variamos a tenso do pino 13 atravs do PWM, alteramos a intensidade
de luz emitida pelo LED.
valorLido = analogRead(A0); // valor entre 0 e 1024

Para variarmos o PWM, usamos o valor analgico lido no potencimetro e

armazenamos na varivel valorLido, que armazena valores entre 0 e 1023. Porm, para
que seja possvel usar essa varivel para controlar o PWM, devemos mudar sua escala
para 0 a 255. Para isso usaremos a funo. Tal funo recebe uma varivel e muda sua
escala.
pwm = map(valorLido, 0, 1023, 0, 255); // Mudana de escala

Depois de mudarmos de escala, basta escrevermos o valor de PWM na sada do

LED.
analogWrite(led,pwm);//Escreve no led um sinal PWM proporcional ao valorLido

34

6. [EXTRA] Interrupo
Imagine que voc esteja fazendo seu bolo e no meio da receita seu telefone toque.
Possivelmente voc ir parar o que est fazendo e ir atender o telefone, assim que
encerrar a chamada voc ir retornar ao ponto que parou em sua receita.
Quando estamos executando um tarefa muitas vezes temos que a interromper para
resolver outra tarefa importante para s depois retornar do ponto que se parou. Isso se
chama interrupo e usada com freqncia na programao de microcontroladores.
Uma interrupo tem dois pontos chaves, so eles:

Condio de interrupo

a condio que indica uma interrupo. Ela avisa ao programa que a hora de
executar uma tarefa extraordinria. No nosso exemplo, essa condio o toque do
telefone.

Funo a ser executada

Quando algo indica a interrupo, temos que executar uma lista de instrues
referentes a essa interrupo. No exemplo dado, temos que parar de fazer o bolo e ir
atender ao telefone. A funo atender telefone uma funo extraordinria que s
executada pelo fato de ter ocorrido a condio de interrupo, o toque do telefone.

Para aprender como implementar uma interrupo, vamos fazer a experincia 4.

Nela voc poder entender melhor esse conceito de interrupo em um microcontrolador.

6.1.

Experincia 6 Implementando uma interrupo

6.1.1. Ingredientes

Boto de presso
LED 5mm
Resistor 1k
Resistor 470
Fios Jumpers
Protoboard

6.1.2. Misturando os ingredientes

Agora vamos conectar os componentes do projeto. Para isso, monte seu circuito
conforme a figura a seguir.
Garanta que seu Arduino esteja desligado durante a montagem e que o seu LED
esteja conectado corretamente, com a perna mais longa (Anodo) conectado ao resistor e
35

a perna menor (catodo) ao GND.

Figura 22 - Circuito da experincia 6

6.1.3. Levando ao forno

Conecte seu Arduino ao computador e abra a IDE Arduino. No menu Tools,
certifique-se que a porta serial (serial port) est selecionada e que a placa configurada a
que voc est usando (board).
6.1.4. Preparando a cobertura
Crie um programa (sketch) e salve com o nome de programa_interrupcao.
Com o seu programa salvo, escreva nele o cdigo conforme escrito abaixo.
// Existe um LED conectado no pino 13 da maioria dos Arduinos
// Daremos um nome a este pino:
int led = 13;
void interrupo(){
digitalWrite(led, HIGH); // Liga o LED (HIGH = nvel lgico alto)
delay(5000);
}
// Esta funo "setup" roda uma vez quando a placa e ligada ou resetada
void setup() {
pinMode(led, OUTPUT); // Configura o pino do led (digital) como sada
attachInterrupt(0,interrupcao,RISING); //Configurando a interrupo
}
// Funo que se repete infinitamente quando a placa ligada
void loop() {
digitalWrite(led, HIGH); // Liga o LED (HIGH = nvel lgico alto)
delay(1000);
// Espera um segundo
digitalWrite(led, LOW); // Desliga o LED (LOW = nvel lgico baixo)
delay(1000);
// Espera um segundo
}

Depois de escrever o cdigo, clique em Upload para que o programa seja

36

transferido para seu Arduino.

6.1.5.

Experimentando o prato
Caso tenha ocorrido tudo como esperado, o LED deve piscar intermitentemente.

Quando voc apertar o boto, o LED da protoboard permanecer aceso por 5 segundos.
Caso voc no pressione o boto novamente, ele voltar a piscar.

6.2.

Entendendo o Hardware
As placas Arduino possuem pinos que podem desempenhar a funo de entrada

de sinal para interrupo externa. No Arduino UNO so as portas digitais 2 e 3, que para
tal funo so nomeadas de INT0 e INT1, respectivamente. Veja a tabela a seguir com os
pinos de cada placa Arduino que possuem essa qualidade.
Board

int.0

int.1

int.2

int.3

int.4

int.5

Uno, Ethernet

Mega2560

21

20

19

18

Leonardo

Dessa forma, para que seja possvel o uso da interrupo externa, escolhemos o
pino digital 2 (INT0), no qual conectamos o boto.

6.3.

Entendendo o programa
Com o conhecimento adquirido at agora, voc j pode entender a maioria dos

programas. Dessa forma, iremos nos ater as novidades.

Configurando a interrupo

Para que o Arduino leia uma interrupo, devemos configur-lo. Para tal usaremos
o comando attachInterrupt().
attachInterrupt(INT,FUNO,MODO); //Configurando a interrupo

Como explicado anteriormente, numa interrupo temos dois pontos chaves: a

condio da interrupo e a funo que ser executada. Dessa forma, o comando
attachInterrupt usado para informar ao programa esses dados. So eles:
INT: Nmero da porta usada para a interrupo. No Arduino UNO INT 0
corresponde porta digital 2 e INT 1 corresponde porta digital 3;
FUNO: Nome da funo que ser chamada quando ocorre a interrupo;
MODO: Define em qual tipo de variao do sinal a interrupo ser disparada.
As opes so:
37

LOW: Dispara a interrupo quando a tenso no pino est em 0V

CHANGE: Dispara sempre que o sinal no pino muda de estado,

borda 0V (0) para 5V(1) ou vice-versa;

RISING: Dispara somente borda de subida, 0v (0) para 5V ( 1);

FALLING: Dispara somente borda de descida, 5V (1) para 0V (0)

Em nosso programa, usaremos esse comando da seguinte forma:

attachInterrupt(0,interrupcao,RISING); //Configurando a interrupo

Portanto, temos como condio de interrupo a mudana de estado de 0V (0)

para 5V(1) no pino digital 2 (INT 0) e a funo a ser executa se chama interrupo.

Funo interrupcao()

Como j explicado no captulo 2, funo um bloco de tarefas a serem executadas

pelo programa quando solicitada.
void interrupo(){ //Funo executada quando ocorre a interrupo externa
digitalWrite(led, HIGH); // Liga o LED (HIGH = nvel lgico alto)
delay(5000);
}

No nosso caso, a funo ser solicitada quando ocorrer a interrupo. As tarefas a

serem executadas sero: acender o LED e esperar 5 segundos.

38

7. Apndice - Tabela de consulta

delay(t)
delayMicroseconds(t)
millis()
randomSeed(referncia)
random(min,max)
abs(x)
map(valor,min1,max1,min1
,max2)
sin(x)

Funes Matemticas e de tempo

O programa tem uma pausa de t milissegundos
O programa tem uma pausa de t microssegundos
Retorna o tempo, em milissegundos, desde que o programa comeou a rodar
Gera uma referncia para o primeiro nmero aleatrio (Funo setup)
Gera um valor pseudo aleatrio int entre min e max (a funo acima necessria)
Retorna o mdulo (valor absoluto) do nmero real passado como parmetro
Converte um valor inserido em uma faixa de valores para um proporcional em uma
nova faixa de valores. Mudana de range.
Retorna o seno de x(rad)

anologRead(Pino)

Entradas Analgicas
L entrada analgica 0-5V transformando em 10 bits (resoluo 4,9mV)

Pinos analgicos podem ser usados como porta digitais usando a funo pinMode(), quando usado como porta
analgica no necessitam de configurao.

Sadas/entradas Digitais e PWM

pinMode(porta,Tipo)
Define se a porta ser uma entrada (TIPO=INPUT) ou uma sada (TIPO= OUTPUT).
digitalWriter (pino, VL)
Coloca 0V (VL =LOW) ou 5V(VL = HIGH) na sada.
digitalRead(pino)
L o sinal digital no pino citado.
analogWrite(pino, x)
Sada PWM 500Hz ( 0 <= x <=255).
analogWrite(pino, x)
Sada PWM 500Hz ( 0 <= x <=255).
tone(pino,frequncia,durao) Gera uma frequncia no pino durante um determinado tempo.
tone(pino,frequncia)
Gera uma frequncia no pino at que ocorra um comando de mudana de Freq.
noTone(pino)
Cessa a gerao do tom no pino.
Mede a largura em microssegundo de um pulso no pino digital, valor o tipo de
pulseIn(pino,valor,espera)
pulso a ser medido (LOW ou HIGH), espera (opcional) faz com que a medida do
pulso s comece aps o tempo em microssegundos especificado.
uma interrupo, ou seja, caso a condio modo ocorra no pino especificado a
funo executada imediatamente.
LOW
Dispara a interrupo quando o pino est em 0
attachInterrupt(pino,funo,
CHANGE
Dispara sempre q o pino muda de estado (borda 0-> 1 ou vicemodo)
versa)
RISING
Somente borda de subida (0 para 1)
FALLING
Somente borda de descida (1 para 0)

39

Variveis
Tipo de dado
boolean
int
unsigned int
Word
Char
usigned char
Byte
void keyword
Long
Usigned long
float
Double
string
array (vetor)
tipovar nomeMatriz[n de
posies]

Serial.begin(TAXA)
Serial.end()
Serial.flush()
Serial.available()
Serial.read()
Serial.print(valor,formato)
Serial.println(valor,formato)

RAM
1 byte
2 bytes
2 bytes
2 bytes
1 byte
1 byte
1 byte
N/A
4 bytes
4 byte
4 byte
4 byte
1 byte + x
1byte + x

Intervalo numrico
0 a 1 (false ou true)
-32.768 a 32.767
0 a 65.535
0 a 65.535
-128 a 127
0 a 255
0 a 255
N/A
-2.147.483.648 a 2.147.483.647
0 a 4.294.967.295
-3,4028235e+38 a 3,4028235e+38
-3,4028235e+38 a 3,4028235e+38
Sequncia de caracteres
Sequncia de variveis

Comunicao Serial
Habilita a porta serial e fixa a taxa de transmisso (funo setup)
Desabilita a porta serial para permitir o uso dos pinos digitais
Libera caracteres que esto na linha serial, deixando-a vazia e pronta para entradas
e sadas.
Retorna o nmero de bytes disponveis para leitura no buffer da porta serial.
L o primeiro byte que est no buffer da porta serial
Envia para a porta serial um caractere ASCII
O mesmo que o anterior, porem pula uma linha
Operadores de Comparao

==
!=
<
>
>=
<=

Igual
Diferente
Menor
Maior
Maior ou igual
Menor ou igual
Operadores Lgicos

&&
||
!

AND
OR
NOT
Smbolos Compostos

x++
x-x+=y
x-=y

Incrementa x
Decrementa x
x = x+y
x = x-y
40

x*=y
x/=y

x = x*y
x = x/y

{}
;
//
/* ... */

Smbolos
Entre as chaves fica o contedo da funo
Final de um comando/linha
Linha de comentrio
Comentrio de varias linhas
Funes

If(condio)
{}
else
{}

Funo Se e Se no

if(condio)
{}
else if(condio 2)
{}

Funo Se em cascata

switch(expresso){
case expresso = x: Bloco1;
break;
case expresso = y: Bloco2;
break;
default: bloco3
}

Funo Caso

while(condio){bloco
funes}

Funo Enquanto

do{
bloco de instrues
}
while(condio);

Funo Enquanto, ela executada pelo menos uma vez.

for(var;condio;incremento)
{}

Funo Para

(condio) ? bloco1:bloco2;

Operador ternrio ? caso condio seja verdadeira ele executa o bloco 1, caso
contrario, executa o bloco 2.
Ex.: y = (x >10)? 15:20; // caso x>10 y=15, caso contrario, y = 20

41

J parou pensar o que aconteceria se todos soubessem como criar robs? Todos
compartilhando seus conhecimentos e ajudando outras pessoas em seus projetos, projetos
inovadores sendo criados a todo instante. Tudo isso sendo feito por um nico propsito, mudar
o mundo.
Essa revoluo j vem acontecendo e a internet tem unido as pessoas de forma nunca
vista antes. O conhecimento nunca foi to acessvel como tem sido agora e a pessoas tm cada
vez mais aderido filosofia do Open Source.
O Vida de Silcio quer fazer parte de tudo isso ajudando as outras pessoas a construrem
um mundo melhor. Tem muita coisa para ser criada ou melhorada, como por exemplo, a robtica
de reabilitao, rea que ainda tem muito para evoluir.
Para isso, montamos uma loja onde oferecemos a maior variedade possvel de itens para
confeco de projetos de robtica, eletrnica e automao, com preos amigveis.
Alm disso, temos um blog com tutoriais bacanas e didticos para que todos possam
aprender a usar um Arduino e outras placas de desenvolvimento, de forma simples e prtica.
Conhea nosso site, ficaremos felizes em lhe receber!
Atenciosamente,
Equipe Vida de Silcio

42