Arduino Simples e Divertido e Simples-V3 PDF

Arduino Simples e
Divertido
Explore o potencial do Arduino
com
os módulos da GBK Robotics
Cláudio Vieira Oliveira e Humberto
Zanetti
Arduino Simples e
Divertido
Explore o potencial do Arduino
com
os módulos da GBK Robotics
Copyright © 2016, Cláudio Luís Vieira Oliveira e Humberto Augusto
Piovesana Zanetti
Editoração, fotografias, ilustrações e revisão ortográfica:

Cláudio Luís Vieira Oliveira e Humberto Augusto Piovesana Zanetti
Capa:
Claudia Baptistella Oliveira
Todos os direitos reservados e protegidos pela Lei 9610 de 19/02/1998. Todas as

informações contidas nesta obra são de exclusiva responsabilidade dos autores.
Nenhuma parte desta obra pode ser reproduzida ou transmitida por qualquer meio,
sem prévia autorização por escrito dos autores. O mesmo se aplica às
características gráficas e à editoração eletrônica desta obra.
Alguns nomes de empresas e respectivos produtos e/ou marcas foram citados
apenas para fins didáticos, não havendo qualquer vínculo dos mesmos com a obra.
Dentro dos códigos de programação, algumas palavras não foram acentuadas
por questões técnicas relacionadas às linguagens de programação utilizadas. Os
autores acreditam que todas as informações apresentadas nesta obra estão
corretas. Contudo, não há qualquer tipo de garantia de que o uso das mesmas
resultará no esperado pelo leitor, principalmente quando se tratar de códigos de
programação. Caso seja(m) necessária(s), os autores disponibilizarão errata(s) no
site www.profclaudio.com.br.
Dados Internacionais de Catalogação na Publicação (CIP)

O482a Oliveira, Cláudio Luís Vieira Oliveira
Arduino Simples e Divertido / [texto de Cláudio Luís Vieira
Oliveira e Humberto Augusto Piovesana Zanetti]. – Salvador:
Asè Editorial, 2016.
252p.
ISBN: 978-85-92861-14-8
1. Informática. 2. Arduino (Controlador Programável).
I. Título.
CDD: 005.133
Impresso no Brasil / Printed in Brazil

À minha esposa Claudia, por tantos e tantos anos
de companheirismo, comunhão e amor.
À minha filha Franciele

com muito amor.
Aos meus pais Maria Creyde e Manoel

pela dedicação e amor à família.
Ao grande amigo Humberto pelo

inúmeros projetos compartilhados.
Cláudio Vieira Oliveira
À minha esposa Flavia, por seu incentivo

e dedicação.
Ao meus pais, Alberto e Célia,

e meus irmãos, Luis Gustavo e Pedro,
por sempre acreditarem em mim.
E ao meu grande amigo Cláudio, pela

parceria nos projetos nesses anos.
Humberto Zanetti
Sobre os Autores
Cláudio Luís Vieira Oliveira
Mestre em Sistemas de Computação pela
Pontifícia Universidade Católica de Campinas e
bacharel em Análise de Sistemas pela
Universidade Metodista de Piracicaba. Possui
mais de 25 anos de experiência na área de
Ciência da Computação. Coordenador de Curso e
Professor da Faculdade de Tecnologia de Jundiaí
(FATEC) e Professor na Faculdade de Tecnologia
de Bragança Paulista (FATEC).
Humberto Augusto Piovesana Zanetti

Doutorando em Tecnologia pela Faculdade de
Tecnologia da Universidade Estadual de
Campinas (FT - UNICAMP) e Mestre em Ciência da
Computação pela Faculdade de Campo Limpo
Paulista (FACCAMP). Há 11 anos atuando no
ensino técnico e superior. Atualmente professor
na Escola Técnica Rosa Perrone Scavone (Itatiba,
SP) e na Faculdade de Tecnologia de Jundiaí
(FATEC). Na UNICAMP é integrante do LIAG
(Laboratório de Informática, Aprendizagem e
Gestão).
Conheça Também...
Escrito pelos mesmos autores, o livro
Arduino Descomplicado – Como Elaborar
Projetos de Eletrônica, publicado pela Editora
Érica em 2015, apresenta os conceitos básicos e
avançados que envolvem o Arduino, considerado
o principal marco na história do hardware livre. O
Arduino cria uma ponte entre os mundos das
ideias, da eletrônica e computação,
possibilitando que uma ideia saia do papel e se
transforme em realidade de maneira rápida e
simples. A prototipação rápida é um convite à
experimentação. Este livro traz, ainda, a história
da ferramenta e
analisa
conhecimentos de
eletrônica básica.
Orienta quanto à
criação do
primeiro projeto,
destacando os
principais compo-
nentes e o
processo de
montagem do
circuito. Discorre
sobre entradas e
saídas digitais e
analógicas, portal
serial, displays,
sensores e
módulos. Por fim,
explica os conceitos de motores e servo-motores,
Android e a documentação de projetos com o
programa Fritzing.
Índice
Capítulo 1:.......................................................13
Introdução.......................................................13
Itens Necessários............................................17
Conceitos Básicos da Linguagem....................20
Capítulo 2:.......................................................35
Saídas Digitais.................................................35
Projeto 1: PISCA-PISCA....................................38
Projeto 2: SEMÁFORO......................................43
Projeto 3: SEQUENCIAL DE LEDS.....................47
Projeto 4: CONTADOR BINÁRIO........................52
Projeto 5: SEMÁFORO COMPLETO....................58
Projeto 6: BUZZER...........................................64
Projeto 7: O ROBÔ EMITE SONS.......................68
Capítulo 3:.......................................................71
Comunicação Serial.........................................71
Projeto 8: CONTROLE ATRAVÉS DA SERIAL......74
Projeto 9: CONTROLANDO O ROBÔ.................78
Capítulo 4:.......................................................83
Saídas PWM.....................................................83
Projeto 10: LED PULSANTE..............................84
Projeto 11: “SONO”.........................................88
Projeto 12: LED RGB........................................91
Capítulo 5:.......................................................93
Entradas Digitais.............................................93
Projeto 13: BOTÃO LIGA-DESLIGA....................94
Projeto 14: SELECIONANDO AS FUNÇÕES DO
ROBÔ...............................................................99
Projeto 15: CONTADOR COM O DADO
ELETRÔNICO..................................................104
Projeto 16: DADO ELETRÔNICO.....................110
Projeto 17: TIRO AO ALVO..............................116
Projeto 18: TIRO AO ALVO COM EFEITOS
SONOROS......................................................123
Projeto 19: CONTADOR BINÁRIO COM BOTÃO129
Projeto 20: CONTADOR BINÁRIO COM ENCODER
......................................................................136
Capítulo 6:.....................................................145
Entradas Analógicas......................................145
Projeto 21: SENSOR CREPUSCULAR..............146
Projeto 22: SENSOR DE LUMINOSIDADE........150
Projeto 23: “DESPERTANDO O ROBÔ”............154
Projeto 24: TERMÔMETRO.............................159
Projeto 25: ACIONANDO RELÉS.....................164
Capítulo 7:.....................................................167
Display de LED..............................................167
Projeto 26: DISPLAY DE LED..........................168
Projeto 27: MEDIDOR DO NÍVEL DE ILUMINAÇÃO
......................................................................175
Projeto 28: DADO ELETRÔNICO COM DISPLAY DE
LED................................................................181
Projeto 29: CONTADOR HEXADECIMAL..........185
Projeto 30: CONTADOR BINÁRIO E DECIMAL. 190
Capítulo 8:.....................................................197
Infravermelho................................................197
Projeto 31: INTERRUPTOR DE PROXIMIDADE. 198
Projeto 32: SEMÁFORO ACIONADO POR
PROXIMIDADE................................................205
Projeto 33: SENSOR DE DISTÂNCIA................209
Projeto 34: SENSOR DE DISTÂNCIA COM
INDICAÇÃO SONORA......................................214
Projeto 35: CONTROLE REMOTO....................219
Projeto 36: CONTROLANDO O ROBÔ
REMOTAMENTE..............................................227
Capítulo 9:.....................................................233
ATtiny85........................................................233
Projeto 37: PROGRAMANDO O ATTINY85 ATRAVÉS
DO ARDUINO.................................................235
Projeto 38: SEMÁFORO COM ATTINY85..........243
Projeto 39: TERMOSTATO COM ATTINY85......246
Projeto 40: CONTROLE DE ESTUFA COM O
ATTINY85.......................................................250
>
Cláudio Vieira Oliveira e Humberto Zanetti
Capítulo 1:
Introdução
O Arduino é uma versátil plataforma de
prototipagem eletrônica, de hardware e software
aberto, de baixo custo e muito fácil de usar,
mesmo para pessoas que possuem pouco ou
nenhum conhecimento de eletrônica. Quando
falamos em Arduino devemos ter em mente três
conceitos: hardware que é a placa que possui
como componente central um microcontrolador
da família ATmega; software que consiste em
uma linguagem de programação e um ambiente
de desenvolvimento derivados do Processing. O
terceiro conceito é a comunidade, composta por
um grande número de pessoas que
compartilham os seus conhecimentos e projetos
na Internet, disseminando a plataforma.
14
Arduino Simples e Divertido
Figura 1.1: Placa Arduino Uno R3

A placa Arduino é muito parecida com um
computador de pequeno porte, sendo composta
pelo microcontrolador, memória RAM, memória
secundária (memória flash), clock e comunicação
USB entre outras funcionalidades. Na Figura 1.1
temos o modelo mais popular dos Arduinos que é
o Uno R3, porém, para os projetos deste livro
qualquer outro modelo de Arduino pode ser
usado sem restrições.
O Arduino Uno R3 apresenta 14 pinos que

podem ser utilizados como entradas ou saídas
digitais (pinos 0 a 13), sendo que os pinos 3, 5, 6,
9, 10 e 11 também podem utilizar Pulse Width
Modulation (PWM) para gerar um conjunto de
valores inteiros entre 0 e 255. Os pinos de A0 a
A5 correspondem às entradas analógicas, que
recebem uma tensão entre 0 e 5V e o produzem
em uma escala de 0 a 1023. Também temos os
pinos 3,3V, 5V e GND (Terra) permitem alimentar
os componentes dos circuitos conectados ao
Arduino. Possui um microprocessador
ATmega328, com uma memória RAM de 2KB,
memória Flash de 32KB e clock de 16MHz.
O ambiente de desenvolvimento do
Arduino pode ser gratuitamente baixado dos
sites www.arduino.cc ou www.arduino.org. Nestes
sites e em muitos outros, também estão
disponíveis as instruções para realizar a
instalação em diversos sistemas operacionais,
além de fóruns para tirar dúvidas e obter maiores
informações.
15
O ambiente de programação (Figura 1.2) é

muito simples e intuitivo. Um programa, que no
Arduino é chamado de sketch, apresenta duas
funções básicas: setup() e loop().
Figura 1.2: Ambiente de Desenvolvimento do

Arduino
A função setup() deverá conter o código

que irá executar apenas uma vez, quando o
sketch iniciar. Normalmente colocamos nesta
função as definições iniciais do programa.
A função loop() irá executar

continuamente as instruções que estão lá até
16
que outro sketch seja carregado na memória

Flash do Arduino. É importante notar que no
Arduino é possível armazenar e executar um
sketch por vez, desta forma, sempre quando
transferimos um sketch esse irá substituir o
programa que estava anteriormente carregado
na memória Flash. Também observe que como o
sketch fica armazenado na memória Flash,
mesmo quando desligamos o Arduino, o
programa continua armazenado e irá entrar
novamente em execução quando o Arduino for
ligado novamente.
17
Itens Necessários
Os seguintes módulos da GBK Robotics

serão utilizados no desenvolvimento dos projetos
deste livro:
PL1 – Tiny Board PL2 – First Robot
PL3 – Dado Eletrônico P4 – Switch
P5 – Extensão P7 – Sensor de
Luminosidade
18
P9 – Relé de 1 Canal P10 - Sensor de

Temperatura
P12 - Sensor de
P11 – Display Simples Obstáculos
P13 – LDR P14 – IR Receiver
P15 – Buzzer P17 – Encoder
19
P20 – LED RGB Ânodo P21 – Semáforo

Comum
20
Além dos módulos, os seguintes itens

também serão necessários:
1 Arduino Uno R3 (ou 1 ATtiny85

qualquer outro modelo
do Arduino)
20 Cabos para 10 Cabos para

conexão macho-fêmea conexão fêmea-fêmea
21
Conceitos Básicos da Linguagem
Durante todo o livro serão apresentados

vários projetos e seus respectivos códigos-fonte
(ou programas que no Arduino chamamos de
sketch), portanto essa seção terá como objetivo
explicar alguns conceitos básicos da linguagem
de programação utilizada no Arduino, a
linguagem Wiring.
Para aqueles que já conhecem alguma

linguagem de programação, será muito fácil
entender a Wiring. Aqueles que nunca
programaram não devem se preocupar, pois em
todos os projetos terão o detalhamento e
explicação necessários para a compreensão do
leitor.
Esta seção terá como objetivo apresentar

alguns conceitos fundamentais da linguagem,
para que desde o primeiro projeto o leitor se
sinta confortável ao ler os programas. Neste
momento não será abordado todos os conceitos
que envolvem a linguagem e nem ocorrerá um
aprofundamento no assunto, mas em cada
projeto, quando esses recursos apresentados ou
novos recursos surgirem, será detalhado seu uso
e funcionamento para cada projeto.
Um dos recursos mais comuns utilizados

pelos desenvolvedores é o comentário do código-
fonte. O comentário é uma linha ou sentença que
não será executada, que serve apenas para que
22
o próprio programador faça anotações e depois

as leia. Será muito comum durante o livro nos
depararmos com linhas assim:
23
// Isto é um comentário
Outra particularidade da linguagem, que

será notada desde o primeiro projeto, é o uso de
ponto-e-vírgula no final de várias linhas de
comandos. Quando temos um comando,
sinalizamos o final dessa linha de comandos
utilizando o símbolo “;”. Isto informa que essa
linha está no fim e que a execução irá prosseguir
na próxima linha.
As funções setup() e loop()
Em todos os projetos apresentados neste

livro, você irá encontrar as funções setup() e
loop(). Essas funções são obrigatórias para
qualquer sketch em Arduino e separam dois
blocos de código-fonte essenciais, que são
delimitados por um conjunto de chaves { }.
A primeira função, a setup(), é executada

uma única vez. Ela é utilizada principalmente
para fazermos a configuração inicial do nosso
Arduino ou qualquer comando que quisermos
que seja efetuado assim que a placa for iniciada.
Já a função loop() é executada repetidamente,
enquanto a placa estiver em funcionamento.
Nessa função colocamos o núcleo do nosso
código-fonte, as ações que devem se repetir
durante o período em que o Arduino ficará ligado.
24
Portanto, a diferença entre as funções é

que a setup() será executada apenas uma vez e
no momento em que a placa for ligada, enquanto
a função loop() sempre será executada,
repetidas vezes, enquanto a placa estiver ligada.
Toda vez que você reiniciar a placa ou carregar
um programa, a função setup() é executada, e
depois a função loop() inicia sua execução e
repetição.
Constantes e Variáveis
Valores considerados constantes são

aqueles pré-definidos e que não podem ser
alterados como, por exemplo, o valor de PI
(3,141516...). Nos projetos deste livro são
utilizados dois conjuntos de valores constantes:
 Valores da tensão do pino: HIGH é um

valor constante que indica 5 volts e LOW
indica 0 volts no pino;
 Valores de estado de uso do pino: INPUT

indica que o pino atuará como entrada e
OUTPUT indica que o pino atuará como
saída.
Uma variável pode ser compreendida como

uma representação de um dado ou valor, que
pode ser alterado (por isso seu nome “variável”,
que pode variar). Para os projetos em Arduino, o
uso de variáveis é bastante comum, por
exemplo, para indicar o número de um
25
determinado pino na placa ou o valor de um

sensor.
Para criar uma variável temos que definir o

seu tipo de dado e seu identificador (nome). O
tipo de dado a ser definido corresponde ao tipo
de valor que a variável vai armazenar, por
exemplo, se é um número inteiro (que
denominamos como int em Wiring) ou um
número real (que definimos como float) entre
outros. A Tabela 1.1 mostra os principais tipos de
dados usados no Arduino.
Tabela 1.1: Tipos de Dados
Tipo Especificação
boole Possui apenas o valor Verdadeiro (TRUE) ou
an Falso (FALSE).
byte Armazena um número de 8 bits sem sinal que
deve possuir um valor entre 0 e 255.
char Armazena o valor de um caractere.
Representamos o valor desse tipo usando
aspas simples (‘ ’).
int Representa o conjunto dos inteiros naturais
positivos e negativos, incluindo o zero e
abrangendo a faixa de -32.768 a
32.767.
float Representa o conjunto de números reais,
positivos e negativos. Chamados de números
de ponto flutuante, na faixa de
3,4028235E+38 a -3,4028235E+38.
Strin Strings representam um conjunto ou cadeia
g de caracteres, como quando formamos uma
palavra, mensagem ou frase. Representamos
o valor desse tipo usando aspas duplas (“ “).
O identificador é a referência desse valor,

que podemos utilizar no decorrer do programa.
26
Esses identificadores podem conter números e

letras maiúsculas ou minúsculas, devem sempre
começar com uma letra, não podem ter acentos
e nem pode haver espaços em sua definição.
Podemos criar uma variável “vazia” (sem

valor inicial) ou já definir um valor inicial para
ela, utilizando o sinal de atribuição “=”. Abaixo
podemos ver um exemplo de criação e
inicialização de uma variável do tipo de dado
inteiro, chamada “numero” e que recebe como
valor inicial 10:
int numero = 10;
Estruturas Condicionais
Em muitas situações é necessário

programarmos linhas de comandos que devem
ser executadas (ou não) dependendo de alguma
situação. Por exemplo, acender algum LED
somente se alguém apertar um botão. Veja que
nesse caso, o LED só será aceso SE um botão for
pressionado, caso contrário o mesmo deverá
permanecer apagado. Esta condição a ser
verificada, e que define qual conjunto de
comandos será executado, é chamada de
estrutura condicional ou de decisão. A estrutura
condicional mais simples que temos é a if (“se”
em português). Nela definimos uma expressão (a
condição a ser verificada), que caso seja
verdadeira, os comandos agrupados no bloco
27
(demarcados por “{}”) serão executados, caso

contrário, nada será feito. A seguir vemos a
definição da estrutura if:
if (expressao) {
comando 1;
comando 2;
...
}
Podem ocorrer situações em que é

necessário que também se faça algo, caso a
expressão for falsa. Neste caso usamos uma
estrutura auxiliar ao if, o else (“senão” em
português). Essa estrutura vem logo após o
fechamento do bloco do if, e o bloco que ele
demarca só será executado na situação em que a
expressão (definida no if) seja falsa. A estrutura
if-else pode ser observada a seguir:
if (expressao) {
comando 1;
comando 2;
...
}
else {
comando 1;
comando 2;
...
}
28
Também é possível usar de maneira

encadeada este conjunto de estruturas, no caso
de querer verificar uma sequência de várias
condições em cadeia. Podemos verificar uma
condição e caso seja falsa, verificar uma outra, e
assim por diante. Abaixo vemos a estrutura
encadeada:
if (expressao) {
comando 1;
comando 2;
...
}
else if {
comando 1;
comando 2;
...
}
else {
comando 1;
comando 2;
...
}
É importante notar que este encadeamento

pode ser feito com quantas verificações forem
necessárias, apenas sendo necessário conduzir a
uma nova verificação (if) imediatamente depois
de um else.
Há uma estrutura condicional que permite

fazer diversas comparações de valores sobre
uma mesma variável, chamada switch-case
(“escolha-caso” em português). Deve ser definido
29
qual será a variável (definida no switch) que será

comparada e em cada case deve ser definido o
valor a ser comparado. Se a variável apresentar
algum valor definido em um dos “cases”, o bloco
de comando associado será executado. A
estrutura switch-case ainda conta com a opção
de uso do default, que representa um “caso
contrário”, ou seja, define os comandos que
devem ser executados na situação em que o
valor da variável não corresponde a nenhum dos
“cases”. A estrutura switch-case é apresentada a
seguir:
switch (variavel) {
case valor1:
comando 1;
comando 2;
...
break;
case valor2:
comando 1;
comando 2;
...
break;
...
case valorN:
comando 1;
comando 2;
...
break;
default:
comando 1;
30
comando 2;
...
break;
}
Note que o início dos blocos de cada case

não utiliza “{}”. O bloco é iniciado a partir do “:”
e se encerra quando o quando break (“parar”
em português) for executado, encerrando assim
toda a estrutura switch.
Estruturas de Repetição
Em muitas situações necessitamos que um

conjunto de comandos seja executado repetidas
vezes e para isso precisamos adotar estruturas
de repetição, também chamadas de laços de
repetição. Estas estruturas de repetição, assim
como as condicionais, utilizam uma expressão
para definir uma condição. Enquanto a condição
for verdadeira ocorre a repetição e no momento
em que a condição se torna falsa, a repetição é
encerrada.
Umas das estruturas de repetição é a

while (“enquanto” em português), que delimita
um bloco de comandos que serão repetidos,
enquanto a condição verificada for verdadeira. O
momento em que a condição se torna falsa, não
há repetição e a execução continua na próxima
linha do código-fonte. Podemos ver a estrutura
while a seguir:
31
while (expressao) {
comando 1;
comando 2;
...
}
Caso precise que o bloco de comandos seja

feito pelo menos uma vez antes de testar a
condição, a qual determina a próxima repetição
ou não, temos a estrutura do-while (“faça
enquanto” em português). A estrutura do-while é
apresentada abaixo:
do {
comando 1;
comando 2;
...
} while (expressao);
Temos também uma estrutura de repetição

cujo o objetivo é realizar um número
determinado de repetições. A estrutura while
descrita anteriormente encerra sua repetição no
momento em que a condição se torna falsa, que
pode vir na ocorrência de alguma mudança de
valor em alguma variável, sem sabermos a
princípio quantas repetições serão feitas até se
encerrar.
Para as situações em que devemos

controlar a quantidade de repetições, existe uma
estrutura adequada para isso, a estrutura for
(“para” em português). Essa estrutura precisa,
32
além da condição, de um contador e definirmos

como será incrementado essa contagem,
separados por “;”. Abaixo vemos a estrutura for
em detalhes:
for (contador; condicao; incremento) {

comando 1;
comando 2;
...
}
O contador deve ser uma variável numérica

inteira e geralmente se inicia em 0 ou 1. O
incremento especifica de quanto em quanto a
variável de contagem irá incrementar. A
expressão que define a condição de repetição
está relacionada ao limite da contagem. Por
exemplo, se quisermos um ciclo com 10
repetições, iniciando o contador em 1, a
expressão poderia ser “contador <= 10”, tendo
um incremento de 1 no contador a cada
repetição.
Vetores e Matrizes
No desenvolvimento de programas é muito

comum utilizarmos um conjunto de valores, que
se assemelham por terem o mesmo tipo de dado
e mesmo contexto. Imagine que você tem a
necessidade de guardar uma coleção de valores,
como a temperatura de um termômetro, que
será verificado de hora em hora, durante um dia
inteiro. Com isso você teria 24 valores distintos,
33
sendo necessário armazenar em 24 variáveis

diferentes. Se estes valores possuem o mesmo
tipo (no caso o tipo numérico real) e um contexto
(valores de temperaturas) podemos armazená-
las em um conjunto único, que chamamos de
vetor.
Vetor é uma estrutura unidimensional que

através de um único identificador, podemos
armazenar vários valores de mesmo tipo,
diferenciando esses valores através de índices,
que representa sua posição dentro do vetor.
Abaixo temos um exemplo de um vetor de 5
posições que armazena valores do tipo de dado
inteiro.
Figura 1.3: Exemplo de vetor
No exemplo mostrado na Figura 1.3 temos

o vetor chamado “vetor”, que é formado por 5
valores, sendo que seu índice sempre se inicia
em 0. Esses índices podem ser compreendidos
como endereços dos valores dentro do vetor. Por
exemplo, o vetor no índice 0 referencia o valor 7,
o vetor no índice 1 referencia o valor 3, e assim
por diante. Para criar um vetor é bem parecido
com a criação de uma variável, definindo seu
tipo e seu identificador. Adicionamos a isso, a
quantidade de posições que esse vetor terá.
Abaixo vemos a linha de código que cria o vetor
do exemplo:
34
int vetor[5];
Nesta linha podemos notar que o tipo é

inteiro (int), o identificador é “vetor” e entre
colchetes (“[]”) a quantidade máxima de valores
que esse vetor pode armazenar. Também
utilizamos colchetes para referenciar uma
posição específica de um vetor. Por exemplo, a
primeira posição seria vetor[0] e a última seria
vetor[4]. Essa referência indica o valor que está
localizada na posição, por exemplo, somando as
2 primeiras posições (vetor[0] + vetor[1]) seria
equivalente a somar 7 + 3. É importante notar
que os índices sempre começam em 0 (zero).
Estes conjuntos de valores podem ter uma

indexação de mais de uma dimensão, e quando
isso ocorre chamamos a estrutura de matriz. A
diferença para o vetor é que temos mais uma
dimensão de índice, agora na vertical, como
mostra o exemplo na Figura 1.4. Neste caso
temos uma matriz 3 por 5 (3 linhas, 5 colunas)
com valores do tipo inteiro:
Figura 1.4: Exemplo de matriz
35
Assim como no vetor, declaramos a matriz

utilizando os colchetes, mas agora definindo
quais são suas dimensões, sendo definido
primeiro a quantidade de linhas e depois a
quantidade de colunas. Também utilizamos os
colchetes para referenciar os valores dentro da
matriz. Por exemplo temos o valor 1 na posição
matriz[2][0] e o valor 2 na posição matriz[1][4].
Abaixo temos a linha de declaração da matriz do
exemplo acima:
int matriz[3][5];
Operadores
Na linguagem de programação utilizada

pelo Arduino temos quatro grupos de operadores
sendo que cada grupo possui um conjunto de
símbolos que representa a operação. O primeiro
grupo de operadores são os aritméticos. São
utilizados para fazer operações aritméticas
simples, atribuição de valores e incremento
(como já comentamos na estrutura de repetição
for). A Tabela 1.2 apresenta os operadores
aritméticos.
Tabela 1.2: Operadores Aritméticos

Símbolo Operação
= atribuição
+ adição
- subtração
* multiplicação
/ divisão
36
++ incremento
-- decremento
Os operadores relacionais são usados em

expressões lógicas, como aquelas usadas em
estruturas condicionais e de repetição, e
resultam em um valor lógico (verdadeiro ou
falso). A Tabela 1.3 resume o conjunto desses
operadores.
Tabela 1.3: Operadores Relacionais

Símbolo Operação
== igualdade
!= diferença
> maior
< menor
>= maior ou igual
<= menor ou igual
O conjunto de operadores lógicos também

são utilizados em expressões lógicas. Esses
operadores são usados para formar novas
proposições lógicas em conjunto com os
operadores relacionais. Os operadores mais
comuns desse tipo são o de conjunção (E),
disjunção (OU) e negação (NÃO). A Tabela 1.4
apresenta esses operadores e seus respectivos
símbolos usados na linguagem de programação.
Tabela 1.4: Operadores Lógicos

Símbolo Operação
&& E (AND)
|| OU (OR)
! NÃO (NOT)
37
Por fim, temos o conjunto de operadores

bit-a-bit. Esses operadores têm como função a
manipulação dos bits que compõem determinado
dado armazenado, alterando assim seu valor. Por
exemplo, vamos pegar o valor decimal 2 em
binário, representado em 8 bits: 00000010.
Podemos utilizar um operador bit-a-bit para
deslocar o bit para esquerda, tornando a
representação binária em 00000100,
transformando esse valor para 4, na
representação decimal. A Tabela 1.5 mostra o
conjunto de operadores bit-a-bit.
Tabela 1.5: Operadores Bit-a-bit

Símbolo Operação
& E (AND)
| OU (OR)
~ NÃO (NOT)
^ OU exclusivo (XOR)
<< deslocamento de bit à esquerda
>> deslocamento de bit à direita
38
>
Capítulo 2:
Saídas Digitais
Como já mencionado anteriormente o
Arduino possui um conjunto de pinos que são
utilizados como entradas ou saídas digitais
(Figura 2.1).
Figura 2.1: Entradas e Saídas Digitais
Um sinal de digital é aquele apresenta

exclusivamente dois valores 0 ou 1, LOW ou
HIGH. Sendo muito útil para definirmos se algo
deve ser ligado ou desligado, por exemplo, para
controlar o acionamento de um relê que irá
acender ou apagar uma lâmpada ou qualquer
outro dispositivo elétrico ou eletrônico, entre
muitas outras possibilidades.
A definição se um determinado pino digital

irá atuar como entrada ou saída é realizada
através de programação, como veremos a seguir.
Desta forma, quando precisamos utilizar um pino
devemos identificá-lo através do respectivo
número, isto é, entre 0 e 13, como também
39
podemos observar na Figura 2.1. Em seguida,

utilizamos a função pinMode para definir a
função do pino, por exemplo:
pinMode(13, OUTPUT);
Neste caso, note que estamos definindo

que o pino digital 13 do Arduino irá atuar como
OUTPUT, ou seja, saída. Por outro lado, quando
precisamos definir um pino como entrada,
utilizaremos a palavra reservada INPUT.
A função digitalWrite será utilizada para

definirmos o valor de um pino digital, por
exemplo:
digitalWrite(13, HIGH);
Note que utilizamos a função digitalWrite

para colocar um nível 1 (HIGH) no pino 13.
Conforme podemos observar a seguir, podemos
utilizar a palavra reservada LOW para colocar o
nível 0 no pino 13.
digitalWrite(13, LOW);
Quando digitar as instruções no ambiente

de desenvolvimento tome cuidado ao utilizar
letras maiúsculas ou minúsculas, pois, a
40
linguagem de programação utilizada para

programar o Arduino faz diferenciação entre elas.
Desta forma, siga exatamente a grafia utilizada
para cada função e palavra reservada.
Com o intuito de ilustrar a utilização do

ambiente de desenvolvimento e também fixar o
conceito de saídas digitais vamos para a
montagem dos projetos de 1 a 7, descritos neste
capítulo.
41
Projeto 1: PISCA-PISCA
Este projeto é bastante simples e seu

objetivo é utilizar a saída digital do Arduino para
acender e apagar um LED. Conecte o módulo PL2
– First Robot diretamente no Arduino conforme
ilustrado pela Figura 2.2.
Figura 2.2: Ligação do Módulo PL2 – First Robot
Neste projeto também é possível usarmos

módulo P7 – Sensor de Luminosidade ou P21 –
Semáforo (Figura 2.3) em substituição ao módulo
PL2 – First Robot.
42
Figura 2.3: Módulos P7 (à esquerda) e P21 (à

direita)
Para usar o módulo P7 conecte o pino Gnd

do Arduino ao Pino Gnd do módulo e também o
pino 13 do Arduino ao Pino Led1 do módulo
(Figura 2.4).
Figura 2.4: Ligação Módulo P7 – Sensor de

Luminosidade
43
Quando utilizar o módulo P21 – Semáforo

conecte o pino Gnd do Arduino ao Pino Gnd do
módulo e também o pino 13 do Arduino ao Pino
Led1 do módulo P21 (Figura 2.5).
Figura 2.5: Conexão do Módulo P21 – Semáforo
Independente do módulo utilizado na

montagem o sketch (programa) é exatamente o
mesmo, desta forma, carregue o ambiente de
desenvolvimento do Arduino e digite o sketch a
seguir:
// Acender e apagar um LED através da saída

// digital do Arduino
44
// Pino no qual o LED está conectado:

int LED = 13;
void setup() {
// Definir o pino como saída:
pinMode(LED, OUTPUT);
}
void loop() {
// Acender o LED:
digitalWrite(LED, HIGH);
// Aguardar 500ms ou 0,5 segundo:

delay(500);
// Apagar o LED:
digitalWrite(LED, LOW);
// Aguardar novamente 0,5 segundo:

delay(500);
}
Após salvar o sketch (programa), faça a

compilação e, em seguida, conecte o Arduino à
porta USB do computador. Selecione no menu
“Ferramentas”, o modelo da sua placa Arduino e
também a porta serial à qual ela está conectada.
Finalizando, pressione o botão Carregar

para fazer a transferência do sketch para o
Arduino. Observe a Figura 2.6 que mostra a
disposição dos respectivos botões no ambiente
de desenvolvimento do Arduino.
45
Figura 2.6: Ambiente de Desenvolvimento do

Arduino
Observe, neste sketch, o uso das funções

pinMode e digitalWrite já explicadas
anteriormente, além da função delay que irá
permitir que o programa “espere” a quantidade
de milissegundos passada como parâmetro.
Experimente modificar o valor passado na função
delay para alterar a velocidade na qual o LED
pisca. Não se esqueça de transferir o sketch após
cada alteração.
46
Projeto 2: SEMÁFORO
Neste projeto iremos utilizar os três LEDs

(vermelho, amarelo e verde) do módulo PL2 –
First Robot para simular o funcionamento de um
semáforo. A montagem é bastante simples, basta
conectar o módulo PL2 – First Robot diretamente
no Arduino, conforme ilustra a Figura 2.7.
Outra possibilidade de montagem consiste

em substituirmos o módulo PL2 – First Robot pelo
módulo P21 – Semáforo (Figura 2.8). Neste caso
47
devemos realizar as seguintes conexões

utilizando, para isso, um cabo de conexão
macho-fêmea:
a. Gnd do módulo ao pino de Gnd do

Arduino;
b. Led1 do módulo ao pino 11 do Arduino;
c. Led2 do módulo ao pino 10 do Arduino;
d. Led3 do módulo ao pino 9 do Arduino.

48
Independente do módulo usado na

montagem, no ambiente de desenvolvimento do
Arduino digite o seguinte sketch:
// Semáforo
int VERM = 11; // LED Vermelho

int AMAR = 10; // LED Amarelo
int VERD = 9; // LED Verde
void setup() {
pinMode(VERM, OUTPUT);
pinMode(AMAR, OUTPUT);
pinMode(VERD, OUTPUT);
}
void loop() {
digitalWrite(VERM, HIGH);
digitalWrite(AMAR, LOW);
digitalWrite(VERD, LOW);
delay(2000);
digitalWrite(VERM, LOW);
digitalWrite(VERD, HIGH);
delay(3000);
digitalWrite(AMAR, HIGH);
delay(1000);
}
Após transferir o programa, verifique o seu

funcionamento. Note que cada pino digital do
Arduino irá controlar o funcionamento de um
49
LED. Na função setup definimos os três pinos

como saída, enquanto que na função loop
desenvolvemos a sequência de funcionamento
do semáforo, isto é:
1. Ligamos o LED Vermelho e apagamos os

LEDs Amarelo e Verde;
2. Aguardamos 2 segundos, através da
instrução delay (2000);
3. Ligamos o LED Verde e apagamos os outros
dois LEDs;
4. Aguardamos 3 segundos;
5. Ligamos o LED Amarelo e apagamos os
LEDs Vermelho e Verde;
6. Aguardamos 1 segundo;
7. A sequência inicia novamente, pois, está
na função loop e assim sucessivamente.
50
Projeto 3: SEQUENCIAL DE LEDS
Vamos novamente utilizar os três leds

(vermelho, amarelo e verde) do módulo PL2 –
First Robot para criar um efeito de acendimento
dos leds da esquerda para a direita e depois no
sentido contrário, ou seja, da direita para a
esquerda.
A montagem é bastante simples bastando

conectar o módulo PL2 – First Robot diretamente
no Arduino conforme ilustrado pela Figura 2.9.

51
Também podemos utilizar os módulos P7 –

Sensor de Luminosidade ou P21 – Semáforo em
substituição ao módulo PL2 – First Robot.
Figura 2.10: Conexão do Módulo P7 – Sensor de

Luminosidade
Quando o módulo P7 – Sensor de

Luminosidade (Figura 2.10) ou P21 – Semáforo
52
(Figura 2.11) for utilizado devemos realizar as

seguintes conexões utilizando, para isso, um
cabo de conexão macho-fêmea:

Arduino;
53

montagem a programação será a mesma, desta
forma, abra o ambiente de desenvolvimento do
Arduino e digite o seguinte sketch:
// Sequencial de LEDs
int LED1 = 11;

int LED2 = 10;
int LED3 = 9;
void setup() {
pinMode(LED1, OUTPUT);
}
void loop() {
digitalWrite(LED1, HIGH);
digitalWrite(LED2, LOW);
delay(200);
delay(200);
delay(200);
54
delay(200);
}
Analisando o sketch, observe que em

intervalos de 200ms ou 0,2s vamos alternando o
LED que está aceso para criar o efeito de
sequencial. Começamos acendendo o LED1,
depois o LED2, depois o LED3 e novamente o
LED2 e a função loop inicia novamente e
acendemos o LED1 e, assim sucessivamente.
55
Projeto 4: CONTADOR BINÁRIO
O objetivo deste projeto é utilizar três leds

para mostrar os números entre 0 e 7 no sistema
de numeração binário, ou seja 0 (Desligado –
LOW) ou 1 (Ligado – HIGH).
O Led3 é o Núme Led Led Led

menos ro 1 2 3
significativo e 0 Low Low Low
deve ficar à 1 Low Low High
direita, o Led2 2 Low High Low
ocupa a posição 3 Low High High
central, enquanto 4 High Low Low
o Led1 é o mais 5 High Low High
significativo
6 High High Low
ficando localizado
7 High High High
à esquerda.
56
A montagem, bastante simples, pode ser

realizada conectando o módulo PL2 – First Robot
diretamente no Arduino conforme ilustrado pela
Figura 2.12.
Este projeto também pode ser montado

utilizando o módulo P7 – Sensor de Luminosidade
(Figura 2.13), neste caso, utilizando cabos de
conexão do tipo macho-fêmea, efetue as
seguintes ligações:
a. Pino GND do módulo P7 a um dos pinos de

GND do Arduino;
b. Pino Led1 do módulo P7 ao pino 11 do
Arduino;
57
c. Pino Led2 do módulo P7 ao pino 10 do

Arduino;
d. Pino Led3 do módulo P7 ao pino 9 do
Arduino.
Figura 2.13: Conexão Módulo P7 – Sensor de

Luminosidade

macho-fêmea:

Arduino;
58
Figura 2.14: Ligação do Módulo P21 – Semáforo
Inicie o ambiente de desenvolvimento do

Arduino e digite o sketch (programa) a seguir:
int digito[8][3] = {
{ LOW, LOW, LOW }, // 0
{ LOW, LOW, HIGH }, // 1
{ LOW, HIGH, LOW }, // 2
{ LOW, HIGH, HIGH }, // 3
{ HIGH, LOW, LOW }, // 4
{ HIGH, LOW, HIGH }, // 5
{ HIGH, HIGH, LOW }, // 6
{ HIGH, HIGH, HIGH } // 7
};
int LED1 = 11;
59
int LED2 = 10;

int LED3 = 9;
int num = 0;
void setup() {
}
void loop() {
digitalWrite(LED1, digito[num][0]);
num++;
if (num > 7)
num = 0;
delay (1000);
}
Neste tipo de problema o uso do conceito

de matriz irá simplificar a implementação. Desta
forma, note que começamos o programa criando
uma matriz de 8 por 3 que irá conter os estados
possíveis (8) para os três LEDs:
{ LOW, LOW, LOW }, // 0
60

};
Em seguida, na função loop mostrada a

seguir, vamos exibindo o digito binário que será
determinado através do valor da variável num.
Observe que quando o valor desta variável se
tornar maior que 7, atribuímos novamente o
valor 0 para ela reiniciando, desta forma, a
contagem.
void loop() {
num++;
if (num > 7)
num = 0;
delay (1000);
}
61
Projeto 5: SEMÁFORO COMPLETO
O módulo P21 – Semáforo (Figura 2.15)

será utilizado para simularmos um semáforo
completo, isto é, para veículos e pedestres.
Figura 2.15: Módulo P21 – Semáforo
Utilizando um cabo conector macho-fêmea

realize as seguintes conexões (Figura 2.16):

Arduino;
d. Led3 do módulo ao pino 11 do Arduino;
e. Led4 do módulo ao pino 12 do Arduino;
f. Led5 do módulo ao pino 13 do Arduino.
62
Figura 2.16: Ligações do Módulo P21 – Semáforo
Após realizar a montagem, acesse o

ambiente de desenvolvimento do Arduino e
digite o seguinte sketch:
// Semáforo completo
int VERMV = 9;
int AMARV = 10;
int VERDV = 11;
int VERMP = 12;
int VERDP = 13;
void setup() {
pinMode(VERMV, OUTPUT);
pinMode(AMARV, OUTPUT);
pinMode(VERDV, OUTPUT);
63
pinMode(VERMP, OUTPUT);
pinMode(VERDP, OUTPUT);
}
void loop() {
digitalWrite(VERMV, HIGH);
digitalWrite(AMARV, LOW);
digitalWrite(VERDV, LOW);
digitalWrite(VERMP, LOW);
digitalWrite(VERDP, HIGH);
delay(3000);
digitalWrite(VERMV, LOW);
digitalWrite(VERDV, HIGH);
digitalWrite(VERMP, HIGH);
digitalWrite(VERDP, LOW);
delay(1000);
digitalWrite(AMARV, HIGH);
delay (2000);
}
Outra possibilidade de implementação,

mostrada no sketch a seguir, consiste em fazer
com que a luz vermelha de pedestres pisque
enquanto a luz amarela do semáforo dos veículos
está acesa.
// Semáforo completo (com matriz)
int ledVerdPed = 13;

int ledVermPed = 12;
64
int ledVerdCar = 11;

int ledAmarCar = 10;
int ledVermCar = 9;
int i = 0;
int estado[15][6] = {
{1, 0, 0, 0, 1, 3000},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 1, 0, 0, 4000},
{0, 1, 0, 1, 0, 2000}
};
void setup() {
pinMode(ledVerdPed, OUTPUT);
pinMode(ledVermPed, OUTPUT);
pinMode(ledVerdCar, OUTPUT);
pinMode(ledAmarCar, OUTPUT);
pinMode(ledVermCar, OUTPUT);
}
void loop() {
digitalWrite(ledVerdPed, estado[i][0]);
digitalWrite(ledVermPed, estado[i][1]);
digitalWrite(ledVerdCar, estado[i][2]);
digitalWrite(ledAmarCar, estado[i][3]);
65
digitalWrite(ledVermCar, estado[i][4]);
delay(estado[i][5]);
i++;
if (i > 14)
i = 0;
}
Conforme podemos notar no trecho de

programa a seguir, definimos uma matriz que irá
conter o estado do cada um dos LED do semáforo
e o tempo (em milissegundos) para cada fase do
semáforo.
int estado[15][6] = {
{1, 0, 0, 0, 1, 3000},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 0, 0, 1, 200},
{0, 0, 0, 0, 1, 200},
{0, 1, 1, 0, 0, 4000},
{0, 1, 0, 1, 0, 2000}
};
Em seguida, na função loop utilizamos a

variável i para determinar o estado do semáforo
em determinado momento.
66
void loop() {
digitalWrite(ledVerdPed, estado[i][0]);
digitalWrite(ledVermPed, estado[i][1]);
digitalWrite(ledVerdCar, estado[i][2]);
digitalWrite(ledAmarCar, estado[i][3]);
digitalWrite(ledVermCar, estado[i][4]);
delay(estado[i][5]);
i++;
if (i > 14)
i = 0;
}
Note também, neste exemplo, que quando

temos um problema que envolve muitos estados,
a aplicação do conceito de matriz facilita o
desenvolvimento do sketch.
67
Projeto 6: BUZZER
Neste projeto iremos emitir sons através do

Módulo P15 – Buzzer (Figura 2.17). Para a
emissão do som, o buzzer vibra através de um
oscilador. Essa oscilação é determinada por uma
frequência que, por sua vez, define um som
específico.
Figura 2.17: Módulo P15 – Buzzer
O módulo P15 – Buzzer deverá ser

conectado ao Arduino, para isso, ligue o pino
GND do Arduino ao pino GND do módulo P15 e,
em seguida, ligue o pino 9 do Arduino ao pino
Sinal do módulo P15 (Figura 2.18).
68
Figura 2.18: Conexão do Módulo P15 – Buzzer
Agora inicie o ambiente de

desenvolvimento do Arduino e digite o sketch
(programa) a seguir:
int BUZZER = 9;
void setup() {
pinMode(BUZZER, OUTPUT);
}
void loop() {
// Define pino e a frequência:
tone(BUZZER, 1200);
delay(500);
// Silencia o buzzer:
noTone(BUZZER);
delay(500);
}
69
A função tone(BUZZER, 1200) irá fazer

com que o buzzer reproduza a frequência de
1200Hz durante 500ms que é o tempo que foi
definido na função delay. Em seguida, a função
noTone(BUZZER) desliga o buzzer. No também
neste mesmo sketch que utilizamos as funções
tone e noTone existentes na linguagem de
programação do Arduino, porém, a função tone
apresenta duas sintaxes:
 tone (pino, frequência);

 tone (pino, frequência, duração);
Onde pino referencia qual é o pino que irá

gerar a frequência que é o pino do Arduino que
está ligado ao positivo do buzzer. A frequência é
definida em hertz e a duração (opcional) é em
milissegundos. Caso opte pela sintaxe sem
duração é necessário usar a função noTone
(pino) para silenciar o buzzer.
Neste próximo exemplo, iremos usar a

segunda sintaxe da função tone. Observe que a
função tone(BUZZER, 1200, 500) irá
reproduzir a frequência de 1200Hz durante
500ms. Entre no ambiente de desenvolvimento
do Arduino e digite o sketch a seguir:
int BUZZER = 9;
void setup() {
}
70
void loop() {
// Define o pino, a frequência e a duração:
tone(BUZZER, 1200, 500);
delay(1000);
}
Mantenha a mesma montagem, utilizada

nos programas anteriores, acesse o ambiente de
desenvolvimento do Arduino e digite o seguinte
sketch:
int BUZZER = 9;
int numNotas = 10;
// Vetor de inteiros com frequências diversas:

int notas[] = { 261, 277, 294, 311, 330, 349,
370, 392, 415, 440 };
/*
* Notas: C C# D D# E F F# G G# A
* C=Dó D=Ré E=Mi F=Fá G=Sol A=Lá B=Si
* As notas sem o “#”, são as notas naturais
* (fundamentais).
* Aquelas com o “#”, são chamadas “notas
* sustenidas” (por exemplo: C#=Dó Sustenido).
*/
void setup() {
}
void loop() {
for (int i = 0; i < numNotas; i++) {
tone(BUZZER, notas[i]);
71
delay(500);
}
noTone(BUZZER);
}
Neste sketch observe que definindo a

frequência de cada nota musical em um vetor
podemos reproduzir um trecho ou mesmo uma
melodia completa.
72
Projeto 7: O ROBÔ EMITE SONS
Neste projeto iremos utilizar o Módulo PL2 –

First Robot em conjunto com o Módulo P15 –
Buzzer para adicionar efeitos sonoros ao
funcionamento do nosso robô.
O módulo P15 – Buzzer deverá ser

conectado ao Arduino, para isso, ligue o pino
GND do Arduino ao pino GND do módulo P15 e,
em seguida, ligue o pino 6 do Arduino ao pino
Sinal do módulo P15 (Figura 2.19).
Figura 2.19: Conexão do Módulo P15 – Buzzer
Em seguida, conecte o módulo PL2 – First

Robot diretamente no Arduino conforme ilustrado
pela Figura 2.20.
73
Agora inicie o ambiente de

// O Robô emite sons

#define TAM 4
int OLHOE = 12;

int OLHOD = 13;
int LED[] = { 9, 10, 11, 10 };
int BUZZER = 6;
int i;
void setup() {
for (i = 0; i < TAM; i++) {
pinMode(LED[i], OUTPUT);
}
pinMode(OLHOE, OUTPUT);
pinMode(OLHOD, OUTPUT);
74
i = 0;
}
void loop() {
digitalWrite(OLHOE, HIGH);
digitalWrite(OLHOD, HIGH);
digitalWrite(LED[i], HIGH);
// Define o pino, a frequência e a duração:
delay(200);
digitalWrite(LED[i], LOW);
i++;
if (i == TAM)
i = 0;
delay(800);
}
Observe na função loop que iremos

acender os LEDs que representam os olhos do
robô, enquanto o vetor LED será usado para criar
um efeito de sequencial nos LEDs localizados no
corpo do robô, simultaneamente a função tone
reproduz a frequência de 5800Hz durante 100ms.
75
>
Capítulo 3:
Comunicação Serial
A comunicação serial permitirá que o
Arduino envie e receba dados dos outros
dispositivos. A forma mais simples de
implementação consiste em utilizar a própria
conexão USB realizada entre o computador e o
Arduino para realizar a troca de dados. O próprio
ambiente de desenvolvimento do Arduino provê
acesso à comunicação serial através do botão
“Monitor Serial” (Figura 3.1).
Figura 3.1: Botão “Monitor Serial”
76
Após clicar no botão “Monitor Serial” será

exibida uma janela (Figura 3.2) que irá
possibilitar tanto receber quanto enviar dados
através da porta de comunicação serial na qual o
Arduino está conectado.
Figura 3.2: Monitor Serial
Em termos de programação, a classe

Serial é a responsável pela comunicação.
Conforme podemos observar no trecho de
programa a seguir, o método Serial.begin
inicializa a comunicação e estabelece a
velocidade de comunicação, que neste exemplo,
será 9600 bps (bits por segundo).
void setup() {
Serial.begin(9600);
77
Serial.print("Digite 1 para acender o led ");

Serial.println("ou 0 para apagar:");
}
Note também que os métodos Serial.print

e Serial.println são usados para enviar dados
do Arduino para o outro dispositivo que está
conectado que, neste caso, é o próprio
computador.
void loop() {
// Verificar se há bytes a serem lidos na
// entrada serial
if (Serial.available() > 0) {
// Ler o byte que está na entrada serial
int entrada = Serial.read();
}
}
Observe no trecho de programa acima que,

por outro lado, o método Serial.available irá
retornar a quantidades que bytes que estão
disponíveis para serem lidos da entrada serial. O
método Serial.read realiza a leitura de um byte
da entrada serial.
78
Projeto 8: CONTROLE ATRAVÉS DA

SERIAL
Neste projeto vamos utilizar a comunicação

serial para enviarmos comandos do computador
para o Arduino, permitindo, desta forma, acender
ou apagar um LED. A montagem, é bastante
simples, apenas conecte o módulo PL2 – First
Robot diretamente no Arduino (Figura 3.3).

Semáforo em substituição ao módulo PL2 – First
Robot. Se você for utilizar o módulo P7 conecte o
pino Gnd do Arduino ao Pino Gnd do módulo e
também o pino 13 do Arduino ao Pino Led1 do
módulo (Figura 3.4).
79

Luminosidade

80

mesmo. Desta forma, acesse o ambiente de
seguir:
// Exemplo de entrada de dados serial
int LED = 13;

int entrada = 0;
void setup() {
Serial.begin(9600);
Serial.println("Digite 1 para acender o led ou 0 para
apagar:");
}
void loop() {
81
entrada = Serial.read();
// Informar o valor que foi recebido

Serial.print("Recebido - Valor caracter: ");
Serial.print((char) entrada);
Serial.print(", valor numerico: ");
Serial.println(entrada, DEC);
// Acender ou apagar o led de acordo com o

// valor recebido na entrada serial
if (entrada == '0')
else if (entrada == '1')
else
Serial.println("Por favor, digite apenas 0 ou 1!");
}
}
Analisando o código-fonte do sketch, note

que na função setup realizamos a inicialização
da comunicação serial através do método
Serial.begin(9600) e também enviamos uma
mensagem para o monitor serial através do
método Serial.println.
Em seguida, na função loop verificamos se

há dados para serem lidos na entrada serial.
Quando isto ocorre o método Serial.available
retorna um valor maior que zero verificamos se o
byte recebido contém o caractere '0' ou '1'.
82
Neste projeto vamos utilizar a comunicação

serial com o intuito de enviar comandos que irão
fazer com que o robô realize diferentes funções.
Inicialmente, conecte o módulo PL2 – First Robot
diretamente no Arduino, conforme ilustrado pela
Figura 3.6.
Em seguida, acesse o ambiente de

seguir:
83
// Controle das funções do módulo PL2 através

// da entrada serial.
int OLHOE = 12;

int OLHOD = 13;
int VERMELHO = 11;
int AMARELO = 10;
int VERDE = 9;
int NARIZ = 8;
int entrada = 0;
void setup() {
Serial.begin(9600);
pinMode(VERMELHO, OUTPUT);
pinMode(AMARELO, OUTPUT);
pinMode(VERDE, OUTPUT);
pinMode(NARIZ, OUTPUT);
Serial.println("1. Abrir os olhos");
Serial.println("2. Fechar os olhos");
Serial.println("3. Abrir olho esquerdo");
Serial.println("4. Abrir olho direito");
Serial.println("5. Piscar olho esquerdo");
Serial.println("6. Piscar olho direito");
Serial.println("7. Espirrar");
Serial.println("8. Feliz");
}
void loop() {
entrada = Serial.read();
switch (entrada) {
case '1':
84
break;
case '2':
digitalWrite(OLHOE, LOW);
digitalWrite(OLHOD, LOW);
break;
case '3':
break;
case '4':
break;
case '5':
for (int i = 0; i < 5; i++) {
delay (100);
delay (100);
}
break;
case '6':
for (int i = 0; i < 5; i++) {
delay (100);
delay (100);
}
break;
case '7':
digitalWrite(NARIZ, HIGH);
delay(200);
digitalWrite(NARIZ, LOW);
break;
case '8':
for (int i = 0; i < 10; i++) {
digitalWrite(VERMELHO, HIGH);
delay (100);
digitalWrite(VERMELHO, LOW);
85
digitalWrite(AMARELO, HIGH);
delay (100);
digitalWrite(AMARELO, LOW);
digitalWrite(VERDE, HIGH);
delay (100);
digitalWrite(VERDE, LOW);
}
break;
default:
Serial.println("Opção não reconhecida!");
}
}
delay (500);
}
O programa é muito parecido com o

desenvolvido no “Projeto 8: CONTROLE ATRAVÉS
DA SERIAL” apenas adicionamos mais opções. A
estrutura de decisão switch-case realiza a
seleção de cada opção e executa os comandos
associados à determinada funcionalidade.
86
87
>
Capítulo 4:
Saídas PWM
Os pinos digitais 3, 5, 6, 9, 10 e 11, que são
identificados pelo símbolo ~ (til) (Figura 4.1),
também podem ser utilizados como saída PWM
(Pulse Width Modulation). Quando usamos este
tipo de saída é possível trabalhar com um
conjunto de valores inteiros entre 0 e 255 ao
invés de apenas 0 (LOW) ou 1 (HIGH). Desta
forma, é possível controlar a velocidade de um
motor, a intensidade luminosa de um LED, entre
outras possíveis aplicações.
Figura 4.1: Pinos PWM~
Neste caso o pino deve ser configurado

exclusivamente como saída e a função
analogWrite permitirá definirmos o pino, que no
exemplo a seguir é 11 e também o valor gerado
na saída (50), ou seja, um valor entre 0 e 255.
analogWrite (11, 50);
88
Projeto 10: LED PULSANTE
Este projeto é bastante simples e seu

objetivo é utilizar uma saída PWM (Pulse Width
Modulation) do Arduino para criar um efeito de
apagamento e acendimento gradativo do LED.
Conecte o módulo PL2 – First Robot diretamente
no Arduino, conforme ilustrado pela Figura 4.2.

Semáforo em substituição ao módulo PL2 – First
Robot. Para usar o módulo P7 conecte o pino Gnd
do Arduino ao Pino Gnd do módulo e também o
pino 11 do Arduino ao Pino Led1 do módulo
(Figura 4.3).
89

Luminosidade

90

mesmo, desta forma, ligue o Arduino, através do
cabo USB ao computador. Em seguida, carregue
o ambiente de desenvolvimento do Arduino e
digite o sketch a seguir:
// LED pulsante
int LED = 11;

float seno;
int intensidade;
void setup() {
}
void loop() {
for (int i = 0; i < 180; i++) {
seno = sin(i * (3.1416 / 180));
intensidade = int(seno * 255);
analogWrite (LED, intensidade);
delay (20);
}
}
Conforme já explicado, o pino deve ser

configurado como OUTPUT, observe o uso da
função pinMode no setup. Em seguida, na
função loop, geramos valores senoidais entre um
0 e 180 graus. O valor calculado será
multiplicado por 255 que é o valor máximo que
91
pode ser gerado por uma saída PWM e utilizado

na função analogWrite para definir a
intensidade com a qual o LED ser aceso, gerando
o efeito desejado.
92
Projeto 11: “SONO”
Alterando o “Projeto 10: LED PULSANTE”,

vamos criar um efeito com os LEDs que
simbolizam os olhos do robô como se ele
estivesse “caindo de sono”. A montagem é
simples, porém, observe que quando conectamos
o Módulo PL2 – First Robot diretamente ao
Arduino os pinos 12 e 13 que representam os
olhos do robô não estão identificados com o ~
(til) e, desta forma, não poderão ser usados
como saída PWM. Desta forma, conforme
podemos observar na Figura 4.5, as seguintes
conexões deverão ser realizadas através de
cabos com conectores do tipo Macho-Fêmea:
a. O Pino Gnd do PL2 deverá ser conectado a

um dos Pinos Gnd do Arduino;
b. O Pino 2 do PL2 (localizado ao lado do Pino
Gnd do módulo) deverá ser ligado ao pino
11 do Arduino;
c. O Pino 3 do PL2 (localizado ao lado do Pino
Gnd do módulo) deverá ser ligado ao pino
10 do Arduino.
93
Figura 4.5: Conexões do Módulo PL2 – First Robot

// Robô com Sono
int OLHOD = 11;

int OLHOE = 10;
float seno;
int intensidade;
void setup() {
Serial.begin(9600);
}
void loop() {
for (int i = 0; i < 180; i++) {
seno = sin(i * (3.1416 / 180));
94
intensidade = int(seno * 255);

analogWrite (OLHOD, intensidade);
analogWrite (OLHOE, intensidade);
Serial.println(intensidade);
if (intensidade > 0)
delay (40);
else
delay (2000);
}
}
O programa é praticamente idêntico ao

projeto anterior, usamos uma função senoidal
para controlar a intensidade com a qual os LEDs
que representam os “olhos” do PL2, que estão
conectados aos pinos PWM 10 e 11 do Arduino,
acendem.
95
Projeto 12: LED RGB
Um LED RGB possui três LEDs (Vermelho,

Verde e Azul) encapsulados em um mesmo
invólucro sendo que, a partir destas três cores,
podemos gerar uma infinidade de combinações e
efeitos luminosos.
Figura 4.6: Módulo P20 – LED RGB Ânodo Comum
Na Figura 4.7 podemos notar que as

seguintes conexões deverão ser realizadas
através de cabos com conectores do tipo Macho-
Fêmea:
a. Pino Red do P20 no pino 9 do Arduino;

b. Pino Green do P20 no pino 10 do Arduino;
c. Pino Blue do P20 no pino 11 do Arduino;
d. Pino +5v do P20 no pino do Arduino.
96
Figura 4.7: Ligação do P20 ao Arduino

// LED RGB
int VERMELHO = 9, VERDE = 10, AZUL = 11;
int iVermelho, iVerde, iAzul;
void setup() {
pinMode (VERMELHO, OUTPUT);
pinMode (VERDE, OUTPUT);
pinMode (AZUL, OUTPUT);
}
void loop() {
iVermelho = random(256);
iVerde = random(256);
iAzul = random(256);
analogWrite(VERMELHO, iVermelho);
analogWrite(VERDE, iVerde);
analogWrite(AZUL, iAzul);
97
delay(500);
}
Analisando o projeto é possível observar

que os pinos do módulo P20 – LED RGB Ânodo
Comum estão conectados à pinos de saída PWM
do Arduino. Em seguida, para cada componente
de cor (vermelho, verde e azul) é sorteado um
valor aleatório entre 0 e 255. A junção dos
valores dos três componentes irá reproduzir a cor
resultante durante 0,5 segundo, que é
determinado pela função delay. Em seguida,
novos valores são sorteados e assim
sucessivamente.
98
>
Capítulo 5:
Entradas Digitais
Os pinos digitais 0 a 13 do Arduino podem
ser configurados como entrada, ou seja, podem
receber um valor 0 (LOW) ou 1 (HIGH) de um
dispositivo sensor, por exemplo, um botão ou um
sensor de obstáculos, entre outros.
Neste caso, conforme podemos ver no

trecho de programa a seguir, a função pinMode
define determinado pino como INPTUT (entrada).
void setup() {
pinMode(2, INPUT);
}
Enquanto a função digitalRead obtém o

valor recebido pelo pino.
void loop() {
// Obtém LOW (0) - botão não pressionado
// ou HIGH (1) – botão pressionado
int valor = digitalRead(2);
}
99
Projeto 13: BOTÃO LIGA-DESLIGA
O objetivo deste projeto é utilizar o módulo

P4 – Switch (Figura 5.1) para em conjunto com o
módulo PL2 – First Robot acender e apagar um
LED. Lembrando também que o módulo PL2 –
First Robot poderá ser substituído pelo módulo P7
– Sensor de Luminosidade ou P21 – Semáforo.
Figura 5.1: Módulo P4 – Switch
Utilizando fios de conexão Macho-Fêmea

ligue o módulo P4 – Switch ao Arduino (Figura
5.2) da seguinte maneira:
a. Pino Gnd do módulo ao pino de Gnd do

Arduino;
b. Pino +5vcc do módulo ao pino 5 Volts do
Arduino;
c. Pino Out do módulo ao pino digital 2 do
Arduino.
100
Figura 5.2: Conexão do Módulo P4 – Switch
Em seguida, encaixe o módulo PL2 – First

pela Figura 5.3.
Quando utilizar o módulo P7 conecte o pino

Gnd do Arduino ao Pino Gnd do módulo e
também o pino 13 do Arduino ao Pino Led1 do
módulo (Figura 5.4).
101
Figura 5.4: Ligação dos Módulos P7 e P4 ao

Arduino
Por outro lado, se estiver utilizando o

módulo P21 – Semáforo conecte o pino Gnd do
Arduino ao Pino Gnd do módulo e também o pino
13 do Arduino ao Pino Led1 do módulo P21
(Figura 5.5).
102

Arduino

mesmo, desta forma, ligue o Arduino, através do
cabo USB ao computador. Em seguida, carregue
// Botão Liga-Desliga
int LED = 13;

int BOTAO = 2;
int valor;
void setup() {
pinMode(BOTAO, INPUT);
}
103
void loop() {
// Obtém LOW (botão não pressionado)
// ou HIGH (pressionado)
valor = digitalRead(BOTAO);
digitalWrite(LED, valor);
delay (100);
}
Observe que, neste exemplo, o LED

permanece aceso somente enquanto o botão
está pressionado. Outra possibilidade de
programação, mostrada no sketch a seguir,
consiste em realizarmos a manutenção do estado
do botão, isto é, quando pressionamos a primeira
vez o botão, ligamos o LED e o mantemos aceso
mesmo após o usuário soltar o botão. Quando
pressionarmos novamente o botão, vamos
desligar o LED o mantê-lo desligado até que o
botão seja pressionado de novo. Assim sendo, a
cada vez que o botão é pressionado o estado irá
mudar de ligado para desligado ou vice e versa.
// Botão Liga-Desliga com Manutenção de Estado
int LED = 13;

int BOTAO = 2;
int valor;
int anterior = 0;
int estado = LOW;
void setup() {
}
104
void loop() {
if (valor == HIGH && anterior == LOW) {
estado = !estado;
}
digitalWrite(LED, estado);
anterior = valor;
delay (50);
}
105
Projeto 14: SELECIONANDO AS

FUNÇÕES DO ROBÔ
Neste projeto vamos utilizar o módulo P4 –

Switch (Figura 5.6) em conjunto com o módulo
PL2 – First Robot para realizar a seleção das
funções do robô.
Utilizando fios de conexão Macho-Fêmea

ligue o módulo P4 – Switch ao Arduino (Figura
a. Pino Gnd do módulo ao pino de Gnd do

Arduino;
b. Pino +5vcc do módulo ao pino 5 Volts do
Arduino;
c. Pino Out do módulo ao pino digital 2 do
Arduino.
106

pela Figura 5.8.
107
Digite o seguinte sketch no ambiente de

desenvolvimento do Arduino:
// Selecionando as funções do robô
int OLHOE = 12;

int OLHOD = 13;
int VERMELHO = 11;
int AMARELO = 10;
int VERDE = 9;
int NARIZ = 8;
int BOTAO = 2;
int botao;
int anterior = LOW;
int funcao = 0;
void setup() {
}
void loop() {
botao = digitalRead(BOTAO);
if (botao == HIGH && anterior == LOW) {
funcao++;
switch (funcao) {
case 1:
break;
108
case 2:
break;
case 3:
break;
case 4:
for (int i = 0; i < 5; i++) {
delay (100);
delay (100);
}
break;
case 5:
for (int i = 0; i < 5; i++) {
delay (100);
delay (100);
}
break;
case 6:
delay(200);
break;
case 7:
for (int i = 0; i < 10; i++) {
delay (100);
delay (100);
109
delay (100);
}
break;
default:
funcao = 0;
}
}
anterior = botao;
delay (50);
}
Conforme podemos notar no sketch o robô

irá realizar uma função diferente a cada
pressionamento do botão:
1. Abrir os olhos (Ligar);

2. Fechar o olho direito;
3. Fechar o olho esquerdo e abrir o direito;
4. Piscar o olho esquerdo;
5. Piscar o olho direito;
6. Espirrar;
7. Feliz (Sequencial de LEDs);
8. Desligar (default).
110
Projeto 15: CONTADOR COM O DADO

ELETRÔNICO
Neste projeto vamos utilizar o módulo PL3 –

Dado Eletrônico (Figura 5.9) para criar um
contador simples.
Figura 5.9: Módulo PL3 – Dado Eletrônico
Utilizando fios para conexão Macho-Fêmea

ligue o módulo PL3 – Dado Eletrônico da seguinte
maneira (Figura 5.10):
a. Pino Gnd do PL3 ao pino de Gnd do

Arduino;
b. Pino +5vcc do PL3 ao pino 5 Volts do
Arduino;
c. Pino Switch do PL3 ao pino digital 2 do
Arduino;
111
d. Pino LED 1 do PL3 ao pino digital 13 do

Arduino;
e. Pino LED 2 do PL3 ao pino digital 12 do
Arduino;
f. Pino LED 3 do PL3 ao pino digital 11 do
Arduino;
g. Pino LED 4 do PL3 ao pino digital 10 do
Arduino;
h. Pino LED 5 do PL3 ao pino digital 9 do
Arduino;
i. Pino LED 6 do PL3 ao pino digital 8 do
Arduino;
j. Pino LED 7 do PL3 ao pino digital 7 do
Arduino.
112
Figura 5.10: Ligação do Módulo PL3 – Dado

Eletrônico
Conforme podemos observar no sketch a
seguir, sempre que o usuário pressionar o botão,
113
o valor mostrado no dado, que é definido pelo

valor da variável contador, será incrementado.
// Contador com o Dado Eletrônico

// Pinos aos quais os LEDs estão conectados:
int LED1 = 13;
int LED2 = 12;
int LED3 = 11;
int LED4 = 10;
int LED5 = 9;
int LED6 = 8;
int LED7 = 7;
// Pino ao qual o Botão está conectado:

int BOTAO = 2;
int botao;
int anterior = LOW;
int contador = 0;
void setup() {
}
void loop() {
contador++;
114
if (contador > 6)
contador = 0;
mostrarDado(contador);
}
anterior = botao;
delay (50);
}
void mostrarDado(int valor) {

if (valor == 0) {
}
else if (valor == 1) {
}
}
115
}
}
}
}
}
116
Projeto 16: DADO ELETRÔNICO
O objetivo deste projeto é utilizar o módulo

PL3 – Dado Eletrônico (Figura 5.11) para mostrar
valores sorteados entre 1 e 6 criando, desta
forma, um dado eletrônico que pode ser utilizado
em jogos de tabuleiros, substituindo o dado
convencional.
Figura 5.11: Módulo PL3 – Dado Eletrônico

ligue o módulo PL3 – Dado Eletrônico (Figura

Arduino;
Arduino;
117

Arduino;
Arduino;
Arduino;
Arduino;
Arduino;
Arduino;
Arduino;
Arduino.

Eletrônico
118
Acesse o ambiente de desenvolvimento do

Arduino e digite o sketch a seguir:
// Dado Eletrônico

int LED1 = 13;
int LED2 = 12;
int LED3 = 11;
int LED4 = 10;
int LED5 = 9;
int LED6 = 8;
int LED7 = 7;
// Pino ao qual o botão está conectado:

int BOTAO = 2;
int botao;
int anterior = LOW;
void setup() {
randomSeed(analogRead(A0));
}
void loop() {
119

// Exibir o valor sorteado (entre 1 e 6)
mostrarDado(random(1, 7));
// Durante 2 segundos
delay(2000);
// Apagar todos os LEDs

mostrarDado(0);
}
anterior = botao;
delay (50);
}
void mostrarDado(int valor) {

if (valor == 0) {
}
}
120
}
}
}
}
121
}
}
Na função setup iniciamos o gerador de

números aleatórios randomSeed, obtendo um
valor a esmo que está na entrada analógica A0
que não possui nada conectado a ela neste
projeto.
A cada pressionamento do botão

sorteamos um valor entre 1 e 6, que será exibido
nos LEDs através da função mostrarDado,
conforme podemos observar no seguinte trecho
de programa.
if (botao == HIGH anterior == LOW) {
// Exibir o valor sorteado (entre 1 e 6)
mostrarDado(random(1, 7));
// Continua...
}
122
Projeto 17: TIRO AO ALVO
Agora vamos criar um pequeno jogo

utilizando o módulo PL3 – Dado Eletrônico. Neste
jogo será apresentado o “alvo”, isto é, um dos
LEDs do módulo irá piscar durante algum tempo
e, em seguida, os LEDs começarão a ser acesos
em uma ordem aleatória. No momento que o LED
que foi apresentado como “alvo” acender, o
botão deverá ser pressionado. Quando isto
ocorrer, o jogador ganhará pontos, caso
contrário, irá perder pontos. Após um acerto o
jogo apresentará outro “alvo”, o jogador deverá
acertá-lo e assim sucessivamente.

ligue o módulo PL3 – Dado Eletrônico (Figura

Arduino;
Arduino;
Arduino;
Arduino;
Arduino;
Arduino;
Arduino;
123

Arduino;
Arduino;
Arduino.

Eletrônico

// Tiro ao Alvo

int LED1 = 13;
int LED2 = 12;
int LED3 = 11;
int LED4 = 10;
124
int LED5 = 9;
int LED6 = 8;
int LED7 = 7;

int BOTAO = 2;
int botao;
int anterior = LOW;
int alvo;
int led;
unsigned long tempo;
int placar;
bool sortear;
void setup() {
Serial.begin(9600);
placar = 0;
sortear = true;
}
void loop() {
if (sortear) {
alvo = random(7, 14);
sortear = false;
mostrar(alvo);
125
}
led = random(7, 14);
digitalWrite(led, HIGH);
tempo = random (50, 500);
unsigned long inicio = millis();
while (millis() <= (inicio + tempo)) {
if (led == alvo) {
acerto();
sortear = true;
break;
}
else {
erro();
}
}
anterior = botao;
}
digitalWrite(led, LOW);
if (led == alvo && sortear == false) {
erro();
}
}
void mostrar(int pino) {

apagar();
for (int i = 0; i < 3; i++) {
digitalWrite (pino, HIGH);
delay(250);
digitalWrite (pino, LOW);
delay(250);
}
}
void apagar() {
126
}
void acerto() {
placar++;
Serial.print("Placar: ");
Serial.println(placar);
for (int i = 0; i < 3; i++) {
delay(250);
apagar();
delay (250);
}
delay (500);
}
void erro() {
placar--;
if (placar < 0)
placar = 0;
}
O jogo consiste em sortear o LED que será

aceso e que representará o nosso “alvo”. Note os
127
valores entre 7 e 14 correspondem aos LEDs que

estão conectados aos pinos 7 e 13:
Então a função mostrar faz como que esse

LED pisque por alguns instantes, para que o
jogador possa identificar o “alvo”.

apagar();
for (int i = 0; i < 3; i++) {
delay(250);
delay(250);
}
}
Em seguida, outros LEDs são acesos

aleatoriamente, um por vez e também em
intervalos aleatórios.

Quando a posição coincidir com o “alvo” o

usuário deverá pressionar o botão enquanto o
128
LED ainda está aceso, neste caso, a função

acerto será executada. Caso contrário, ou seja, o
botão foi pressionado quando outro LED diferente
do “alvo” estava aceso, a função erro será
executada.

if (led == alvo) {
acerto();
sortear = true;
break;
}
else {
erro();
}
}
anterior = botao;
}
129
Projeto 18: TIRO AO ALVO COM

EFEITOS SONOROS
Vamos melhorar o pequeno jogo de tiro ao

alvo, criado no projeto anterior e que utilizou o
módulo PL3 – Dado Eletrônico. Para fazer isso
iremos acrescentar o módulo P15 – Buzzer, que
irá tocar sons sempre que ocorrer um acerto ou
erro. Desta maneira, o funcionamento do jogo
será o mesmo, ou seja, será apresentado o
“alvo”, isto é, um dos LEDs do módulo irá piscar
durante algum tempo e, em seguida, os LEDs
começarão a ser acesos em uma ordem
aleatória. No momento que o LED que foi
apresentado como “alvo” acender, o botão
deverá ser pressionado. Quando isto ocorrer, o
jogador ganhará pontos, caso contrário, irá
perder pontos. Após um acerto o jogo
apresentará outro “alvo”, o jogador deverá
acertá-lo e assim sucessivamente.

realize as seguintes ligações (Figura 5.14):
a. Pino Gnd do PL3 a qualquer pino Gnd do

Arduino;
Arduino;
Arduino;
Arduino;
Arduino;
130

Arduino;
Arduino;
Arduino;
Arduino;
Arduino;
k. Pino Sinal do P15 ao pino digital 6 do
Arduino;
l. Pino GND do P15 a qualquer pino Gnd do
Arduino.
Figura 5.14: Ligação dos Módulos PL3 e P15 ao

Arduino

131
// Tiro ao Alvo com Efeitos Sonoros

int LED1 = 13;
int LED2 = 12;
int LED3 = 11;
int LED4 = 10;
int LED5 = 9;
int LED6 = 8;
int LED7 = 7;
// Pino ao qual o buzzer está connectado:

int BUZZER = 6;

int BOTAO = 2;
int botao;
int anterior = LOW;
int alvo;
int led;
unsigned long tempo;
int placar;
bool sortear;
void setup() {
Serial.begin(9600);
randomSeed(analogRead(0));
placar = 0;
sortear = true;
132
}
void loop() {
if (sortear) {
sortear = false;
mostrar(alvo);
}
if (led == alvo) {
acerto();
sortear = true;
break;
}
else {
erro();
}
}
anterior = botao;
}
digitalWrite(led, LOW);
if (led == alvo && sortear == false) {
erro();
}
}
133

apagar();
for (int i = 0; i < 3; i++) {
delay(250);
delay(250);
}
}
void apagar() {
}
void acerto() {
placar++;
for (int i = 0; i < 3; i++) {
delay(250);
apagar();
delay (250);
134
}
delay (500);
}
void erro() {
placar--;
if (placar < 0)
placar = 0;
}
O programa basicamente é o mesmo do

“Projeto 17: TIRO AO ALVO”, sendo que apenas
foi acrescentado o acionamento do buzzer, com
diferentes frequências e durações, nas funções
acerto e erro.
135
Projeto 19: CONTADOR BINÁRIO COM

BOTÃO
O módulo P4 – Switch (Figura 5.15) será

utilizado agora para incrementar o valor do
contador binário montado no “Projeto 4:
CONTADOR BINÁRIO”.
Isto é, cada vez que pressionarmos o botão

devemos mostrar o próximo número do contador,
conforme a tabela a seguir. Por exemplo, se
contador está exibindo do valor 2 em binário
010, isto é, Low-High-Low ao pressionarmos o
botão os LEDs deverão exibir o valor 3 (011), ou
seja, Low-High-High.
Núme Led Led Led

ro 1 2 3
0 Low Low Low
1 Low Low High
2 Low High Low
3 Low High High
4 High Low Low
5 High Low High
6 High High Low
136
7 High High High
Além do módulo P4 – Switch, também

vamos utilizar o módulo PL2 – First Robot que
pode ser substituído pelo módulo P7 – Sensor de
Luminosidade ou, ainda, o P21 – Semáforo,
conforme detalhamos a seguir.
Inicie a montagem encaixando o módulo

PL2 – First Robot diretamente no Arduino
conforme ilustrado pela Figura 5.16.
Em seguida, conforme ilustra a Figura 5.17

e utilizando fios para conexão Macho-Fêmea
ligue o módulo P4 – Switch ao Arduino da
seguinte maneira:
137
a. Pino Gnd do P4 ao pino de Gnd do Arduino;

b. Pino +5vcc do P4 ao pino 5 Volts do
Arduino;
c. Pino Out do P4 ao pino digital 2 do Arduino.
Como já mencionado, este projeto também

pode ser montado utilizando o módulo P7 –
Sensor de Luminosidade, neste caso, utilizando
cabos de conexão do tipo macho-fêmea, efetue
as seguintes ligações (Figura 5.18):
a. Pino GND do módulo P7 a um dos pinos de

GND do Arduino;
138
b. Pino Led1 do módulo P7 ao pino digital 11

do Arduino;
c. Pino Led2 do módulo P7 ao pino digital 10
do Arduino;
d. Pino Led3 do módulo P7 ao pino digital 9 do
Arduino.
Figura 5.18: Conexões dos Módulos P4 e P7

macho-fêmea:
a. Gnd do módulo ao pino de Gnd do Arduino;

139
Figura 5.19: Ligações dos Módulos P4 e P21
No ambiente de desenvolvimento do
Arduino digite o seguinte sketch (programa):
// Contador Binário com Botão
{ LOW, LOW, LOW }, // 0
140

};
int LED1 = 11;

int LED2 = 10;
int LED3 = 9;
int BOTAO = 2;
int botao;
int anterior = 0;
int num = 0;
void setup() {
}
void loop() {
num++;
if (num > 7)
num = 0;
}
anterior = botao;
delay (50);
}
Observe que sempre que o botão é

pressionado a variável num é incrementada e o
valor correspondente, armazenado na matriz
141
digito, é utilizado para acender ou apagar os

LEDs.
142
Projeto 20: CONTADOR BINÁRIO COM

ENCODER
Neste próximo projeto iremos usar o

módulo P17 – Encoder (Figura 5.20) para
incrementar e decrementar o valor do contador
binário montado no Projeto 4.
Figura 5.20: Módulo P17 – Encoder
Relembrando que o objetivo deste projeto é

utilizar três LEDs para mostrar os números entre
0 e 7 no sistema de numeração binário, ou seja 0
(Desligado – LOW) ou 1 (Ligado – HIGH). A chave
rotativa (encoder) será utilizada para
incrementar ou decrementar o valor binário
exibido pelos LEDs, conforme mostra a tabela a
seguir.
Núme Led Led Led

ro 1 2 3
0 Low Low Low
1 Low Low High
2 Low High Low
3 Low High High
4 High Low Low
143
5 High Low High

6 High High Low
7 High High High
Há três possibilidades de montagem do
projeto. A primeira delas é utilizando o módulo
PL2 – First Robot em conjunto com o P17 –
Encoder. Inicialmente realize as seguintes
ligações utilizando fios para conexão macho-
fêmea (Figura 5.21):
a. Ligue o pino Sinal 1 do módulo P17 na

entrada analógica A2 do Arduino;
b. Ligue o pino Sinal 2 do módulo P17 na
c. Ligue o pino GND do módulo P17 a um dos
pinos de GND do Arduino.
144
Figura 5.21: Ligação do Módulo P17 – Encoder

pela Figura 5.22.
145

módulo P21 – Semáforo. Neste caso devemos
realizar as seguintes conexões utilizando, para
isso, um cabo de conexão macho-fêmea (Figura
5.23):
a. Conecte o pino GND do módulo P21 a um

dos pinos de GND do Arduino;
b. Conecte o pino Led1 do módulo P21 ao
pino digital 11 do Arduino;
c. Conecte o pino Led2 do módulo P21 ao
d. Conecte o pino Led3 do módulo P21 ao
e. Ligue o pino Sinal 1 do módulo P17 na
f. Ligue o pino Sinal 2 do módulo P17 na
g. Ligue o pino GND do módulo P17 a um dos
146
A terceira opção para a montagem do

projeto consiste em utilizar os módulos P7 –
Sensor de Luminosidade e P17 – Encoder (Figura
5.24), neste caso, utilizando fios para conexão
macho-fêmea:
a. Conecte o pino GND do módulo P7 a um

b. Conecte o pino Led1 do módulo P7 ao pino
digital 11 do Arduino;
c. Conecte o pino Led2 do módulo P7 ao pino
147
d. Conecte o pino Led3 do módulo P7 ao pino

e. Ligue o pino Sinal 1 do módulo P17 na
f. Ligue o pino Sinal 2 do módulo P17 na
g. Ligue o pino GND do módulo P17 a um dos
Para utilizar o módulo P17 – Encoder é

necessário realizar o download da biblioteca
148
RotaryEncoder que está disponível em

http://www.gbkrobotics.com.br/exemplo-
produto/rotaryencoder.zip. Descompacte o
conteúdo do arquivo rotatoryencoder.zip na
pasta > Este computador > Documentos >
Arduino > libraries, conforme ilustra a Figura
5.25.
Figura 5.25: Instalação da Biblioteca

RotatoryEncoder
Após instalar a biblioteca, carregue o

digite o sketch (programa) a seguir:
#include <RotaryEncoder.h>
{ LOW, LOW, LOW }, // 0
149

};
int LED1 = 11;

int LED2 = 10;
int LED3 = 9;
RotaryEncoder encoder(A2, A3);
void setup() {
Serial.begin(9600);
// Habilitar a Interrupção 1 (Pin Change)

// para as entradas analógicas.
PCICR |= (1 << PCIE1);
// Habilitar a interrupção para os pinos

// analógicos 2 e 3.
PCMSK1 |= (1 << PCINT10) | (1 << PCINT11);
}
// Rotina do Serviço de Interrupção 1

// (Pin Change). Esta rotina apenas é chamada
// quando ocorre uma mudança de sinal nos pinos
// A2 e A3
ISR(PCINT1_vect) {
encoder.tick();
}
150
void loop() {
static int pos = 0;
int novaPos = encoder.getPosition();
if (pos != novaPos) {
Serial.println(novaPos);
pos = novaPos;
if (pos >= 0 && pos <= 7) {
digitalWrite(LED1, digito[pos][0]);
}
}
}
Analisando o programa desenvolvido

podemos notar que o encoder é ligado a dois
pinos analógicos:
Em seguida, precisamos na função setup

habilitar as interrupções para os dois pinos
analógicos utilizados:

// Habilitar a interrupção para os pinos

151
Na função loop obtemos a posição do

encoder e, havendo diferença em relação à
posição armazenada anteriormente, atualizamos
o valor a ser exibido nos LEDs.
152
>
Capítulo 6:
Entradas Analógicas
O Arduino apresenta um conjunto de 6
pinos que podem receber um sinal analógico
entre 0 e 5 Volts e converter para um valor
numérico entre 0 e 1023. Nestes pinos podemos
conectar sensores analógicos como sensores de
temperatura, luz ou infravermelho, entre
diversos outros tipos.
Figura 6.1: Entradas Analógicas do Arduino
A função analogRead deverá ser usada

para obtermos o valor que está presente em um
dos pinos analógicos, como podemos observar na
seguinte linha de programa.
int valor = analogRead(A0);
153
Projeto 21: SENSOR CREPUSCULAR
Neste projeto vamos definir o estado de um

LED, ou seja, se o mesmo deve ser aceso ou
apagado através da verificação da luminosidade
do ambiente, simulando o que seria um sistema
de iluminação de emergência. Para isso, iremos
utilizar o módulo P7 – Sensor de Luminosidade
(Figura 6.2).
Figura 6.2: Módulo P7 – Sensor de Luminosidade
Vamos conectar o módulo P7 – Sensor de

Luminosidade ao Arduino da seguinte maneira
utilizando, para isso, fios para conexão macho-
a. Conecte o pino 5v do Arduino ao pino 5Vcc

do módulo P7;
b. Conecte o pino GND do módulo P7 a um
c. Conecte o pino analógico A0 do Arduino ao
pino Sinal Analog. do módulo P7;
154

digital 13 do Arduino.
Figura 6.3: Conexão do Módulo P7
155
Arduino e implemente o seguinte sketch:
int LED = 13;

int LDR = A0;
void setup() {
Serial.begin(9600);
}
void loop() {
int entrada = analogRead(LDR);
Serial.println(entrada);
if (entrada < 200)
else
delay(100);
}
Às vezes, devido às características de

iluminação do ambiente o valor de transição, que
no programa acima foi definido em 200, deve ser
ajustado. Para isso, abra o Monitor Serial do
ambiente de desenvolvimento do Arduino (Figura
6.4), cubra o LDR com o dedo e observe o valor
da leitura. Em seguida, retire o dedo e faça a
leitura novamente. O valor ideal de transição é
um valor médio entre as duas leituras.
156
Figura 6.4: Acesso ao Monitor Serial
157
Projeto 22: SENSOR DE LUMINOSIDADE
Outra possibilidade é utilizarmos os três

LEDs existentes no módulo P7 – Sensor de
Luminosidade para mostrarmos o nível da
intensidade luminosa que o LDR está recebendo.
Vamos conectar o módulo P7 – Sensor de

Luminosidade ao Arduino da seguinte maneira
utilizando, para isso, fios para conexão macho-

do módulo P7;
pino Sinal Analog. do módulo P7;
e. Conecte o pino Led2 do módulo P7 ao pino
f. Conecte o pino Led3 do módulo P7 ao pino
digital 11 do Arduino.
158

159
int LED1 = 13;

int LED2 = 12;
int LED3 = 11;
int LDR = A0;
void setup() {
Serial.begin(9600);
}
void loop() {
int nivel = map(entrada, 0, 1023, 0, 3);
Serial.print(entrada);
Serial.print(" -> ");
Serial.print(nivel);
switch(nivel) {
case 0:
break;
case 1:
break;
case 2:
160
break;
case 3:
break;
}
delay(100);
}
Observe que no trecho de programa a

seguir, obtemos o valor do LDR e mapeamos
entre um valor entre 0 e 3, o qual irá determinar
quais LEDs do módulo P7 – Sensor de
Luminosidade deverão ser acesos.

161
Projeto 23: “DESPERTANDO O ROBÔ”
O módulo P13 – LDR (Figura 6.6) será

usado em conjunto com o módulo PL2 – First
Robot. Quando houver incidência de luz no LDR o
robô irá “acordar”, ou seja, iremos acender os
dois LEDs que representam os seus olhos. Por
outro lado, quando não houver luz, os seus “olhos
serão fechados”, isto é, os LEDs serão apagados.
Figura 6.6: Módulo P13 – LDR
Em primeiro lugar, conecte o módulo PL2 –

First Robot diretamente no Arduino conforme
ilustrado pela Figura 6.7.
162
Como já mencionado, este projeto é

montado utilizando o módulo P13 – LDR, neste
caso, através de fios conectores do tipo macho-
fêmea realize as seguintes ligações (Figura 6.8):
a. Pino 5v do Arduino ao pino +5Vcc do

módulo P13;
b. Pino GND do módulo P13 a um dos pinos
de GND do Arduino;
c. Pino analógico A0 do Arduino ao pino Sinal
módulo P13.
Figura 6.8: Conexão do Módulo P13 – LDR
163

em substituir o módulo P13 – LDR pelo módulo P7
– Sensor de Luminosidade. Nesta opção de
montagem, mostrada na Figura 6.9, as ligações
são realizadas utilizando cabos para conexão
macho-fêmea da seguinte forma:

do módulo P7;
pino Sinal Analog. do módulo P7.
Figura 6.9: Ligação do Módulo P7
Após a montagem do projeto, entre no

164
int OLHOD = 13;

int OLHOE = 12;
int LDR = A0;
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println(entrada);
if (entrada > 200) {
}
else {
}
delay(100);
}
Às vezes, devido às características de

iluminação do ambiente o valor de transição, que
no programa acima, foi definido em 200 deve ser
ajustado. Para isso, abra o Monitor Serial do
ambiente de desenvolvimento do Arduino (Figura
6.10), cubra com o dedo o LDR e observe o valor
da leitura. Em seguida, retire o dedo e faça a
leitura novamente. O valor ideal de transição é
um valor médio entre as duas leituras.
165
166
Projeto 24: TERMÔMETRO
O objetivo deste projeto é obter a

temperatura ambiente através da leitura dos
dados recebidos do módulo P10 - Sensor de
Temperatura (Figura 6.11) que contém um
termistor do tipo NTC. Os termistores podem ser
de dois tipos:
 Termistor PTC (Positive Temperature

Coefficient): Este tipo de termistor tem o
coeficiente de temperatura positivo, ou
seja, a resistência aumenta com o aumento
da temperatura;
 Termistor NTC (Negative Temperature
Coefficient): Este tipo é o inverso do PTC e
seu coeficiente de temperatura é negativo.
Com isto sua resistência diminui com o
aumento da temperatura.
167
Figura 6.11: Módulo P10 – Sensor de Temperatura
O módulo P10 - Sensor de Temperatura

deverá ser conectado ao Arduino (Figura 6.12),
utilizando um fio para conexão macho-fêmea, da
seguinte maneira:
a. Conecte o pino GND do Arduino ao pino

GND do módulo P10;
b. Conecte o pino 5V do Arduino ao pino
+5Vcc do módulo P10;
c. Conecte o pino A0 do Arduino ao pino Sinal-
A do módulo P10.
168
Com o intuito de facilitar o uso do termistor

em nosso sketch podemos utilizar a biblioteca
Thermistor. Esta biblioteca poderá ser baixada
através do link:
http://www.gbkrobotics.com.br/exemplo-produto/
biblioteca-thermistor.zip. Após fazer o download
da biblioteca descompacte o conteúdo do
arquivo dentro da pasta > Este computador >
Documentos > Arduino > libraries, conforme
podemos observar na Figura 6.13:
Figura 6.13: Instalação da Biblioteca Thermistor

169
#include <Thermistor.h>
Thermistor TERM (A0);

float temperatura;
void setup() {
Serial.begin(9600);
}
void loop() {
temperatura = TERM.getTemp();
Serial.print("Temperatura = ");
Serial.print(temperatura);
Serial.print(char(176));
Serial.println("C");
delay (2000);
}
Conforme podemos observar no trecho de

programa a seguir, incluímos a biblioteca de
Thermistor no sketch e, em seguida, indicamos
que o mesmo se encontra conectado ao pino A0
do Arduino.
O método getTemp() irá obter a

temperatura:
170
O funcionamento do sketch pode ser

observado acessando o Monitor Serial (Figura
6.14) e observando a exibição da temperatura
que foi “lida” através do módulo P10 - Sensor de
Temperatura.
Exercícios 
171
1) Utilizando as fórmulas a seguir, modifique o

programa para exibir a temperatura em
Fahrenheit e também em Kelvin.
 F = (C * 9) / 5 + 32
 K = C + 273.15
172
Projeto 25: ACIONANDO RELÉS
Neste projeto será criado um termostato

simples, ou seja, com base na temperatura
obtida pelo módulo P10 – Sensor de Temperatura,
vamos decidir se devemos ou não acionar a
carga que está conectada ao módulo P9 – Relé de
1 Canal (Figura 6.15). Observe também que o
módulo P5 – Extensão será utilizado para realizar
as conexões dos terminais positivos (+5Vcc) dos
módulos P9 e P10.
Figura 6.15: Módulo P9 – Relé de 1 Canal
Utilizando cabos para conexão macho-

fêmea, realize as ligações descritas a seguir
(Figura 6.16):
a. Pino Sinal do P9 ao pino 13 do Arduino;

b. Pino GND do P9 a qualquer pino GND do
Arduino;
c. Pino Sinal-A do P10 ao pino A0 do Arduino;
d. Pino GND do P10 a qualquer pino GND do
Arduino;
e. Pino +5Vcc do P5 ao pino +5V do Arduino.
173
Em seguida, com fios de conexão fêmea-

fêmea, realize as seguintes conexões:
a. Pino +5Vcc do P9 a qualquer pino +5Vcc

do P5;
b. Pino +5vcc do P10 a qualquer pino +5Vcc
do P5.
Figura 6.16: Conexões dos Módulos ao Arduino
Após realizar a montagem do circuito, inicie


float temperatura;
int RELE = 12;
174
void setup() {
pinMode(RELE, OUTPUT);
}
void loop() {
if (temperatura < 25.0) {
// Acionar o relé
digitalWrite(RELE, HIGH);
}
else {
// Desligar o relé
digitalWrite(RELE, LOW);
}
delay (2000);
}
O sketch é bastante simples, observe que

se a temperatura estiver abaixo de 25°C
acionamos o relé, caso contrário, ele ficará
desligado.
175
>
Capítulo 7:
Display de LED
Os displays de LED de 7 segmentos
consistem de uma alternativa muito barata para
exibir informações, principalmente numéricas,
em um projeto desenvolvido com Arduino. Este
tipo de display pode ser do tipo ânodo comum ou
cátodo comum.
176
Projeto 26: DISPLAY DE LED
Neste projeto vamos demonstrar a

utilização do módulo P11 – Display Simples
(Figura 7.1) que consiste em um display de LED
de 7 segmentos com ânodo comum.
Figura 7.1: Módulo P11 – Display Simples
Utilizando um fio de conexão macho-fêmea

realize as conexões a seguir (Figura 7.2) para
ligar o módulo P11 – Display Simples ao Arduino:
a. Pino 5V do Arduino ao pino +5Vcc do

módulo P11;
b. Pino 2 do Arduino ao pino 2 do módulo P11;
c. Pino 3 do Arduino ao pino 3 do módulo P11;
d. Pino 4 do Arduino ao pino 4 do módulo P11;
e. Pino 5 do Arduino ao pino 5 do módulo P11;
f. Pino 6 do Arduino ao pino 6 do módulo P11;
g. Pino 7 do Arduino ao pino 7 do módulo P11;
h. Pino 8 do Arduino ao pino 8 do módulo P11;
i. Pino 9 do Arduino ao pino 9 do módulo P11.
177
Figura 7.2: Ligação do Módulo P11 – Display

Simples
O programa a seguir irá exibir a letra “A” no

módulo P11, assim sendo, acesse o ambiente de
178
int SEG_A = 2;
int SEG_B = 3;
int SEG_C = 4;
int SEG_D = 5;
int SEG_E = 6;
int SEG_F = 7;
int SEG_G = 8;
int PONTO = 9;
int ESPERA = 1000;
void setup() {
for (int pino= SEG_A; pino <= PONTO; pino++) {
pinMode(pino, OUTPUT);
digitalWrite(pino, HIGH);
}
}
void loop() {
digitalWrite(SEG_A, LOW);
digitalWrite(SEG_B, LOW);
digitalWrite(SEG_C, LOW);
digitalWrite(SEG_E, LOW);
digitalWrite(SEG_F, LOW);
digitalWrite(SEG_G, LOW);
delay(ESPERA);
}
Este próximo programa de exemplo irá

exibir um efeito simples de animação no módulo
P11 – Display Simples. No ambiente de
179
int SEG_A = 2;
int SEG_B = 3;
int SEG_C = 4;
int SEG_D = 5;
int SEG_E = 6;
int SEG_F = 7;
int SEG_G = 8;
int PONTO = 9;
int ESPERA = 150;
void setup() {
for (int pino= SEG_A; pino <= PONTO; pino++) {
pinMode(pino, OUTPUT);
}
}
void loop() {
for (int pino = SEG_A; pino < SEG_G; pino++) {
digitalWrite(pino, LOW);
if (pino > SEG_A) {
digitalWrite(pino - 1, HIGH);
}
else {
digitalWrite(SEG_F, HIGH);
}
delay(ESPERA);
}
}
Arduino e digite o seguinte sketch que irá exibir,
no módulo P11 – Display Simples, uma contagem
regressiva de nove até zero.
180
// Matriz com os dígitos de 0 a 9.

byte digitos[10][7] = {
{ 1,1,1,1,1,1,0 }, // = 0
{ 0,1,1,0,0,0,0 }, // = 1
{ 1,1,0,1,1,0,1 }, // = 2
{ 1,1,1,1,0,0,1 }, // = 3
{ 0,1,1,0,0,1,1 }, // = 4
{ 1,0,1,1,0,1,1 }, // = 5
{ 1,0,1,1,1,1,1 }, // = 6
{ 1,1,1,0,0,0,0 }, // = 7
{ 1,1,1,1,1,1,1 }, // = 8
{ 1,1,1,0,0,1,1 } // = 9
};
void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pontoDecimal(false);
}
void pontoDecimal(boolean ponto) {

digitalWrite(9, ponto);
}
void escrever(int digito) {

int pino = 2;
for (int seg = 0; seg < 7; seg++) {
digitalWrite(pino, !digitos[digito][seg]);
pino++;
181
}
}
void limpar() {
byte pino = 2;
pino++;
}
}
void loop() {
for (int cont = 9; cont >= 0; cont--) {
escrever(cont);
boolean ponto = true;
for (int i = 0; i < 4; i++) {
delay(250);
pontoDecimal(ponto);
ponto = !ponto;
}
}
limpar();
delay(1000);
}
Quando precisamos exibir vários dígitos no

display é mais indicada a criação de uma matriz,
onde cada linha contém um dígito, no exemplo a
seguir, temos os valores entre 1 e 9:

{ 1,1,1,1,1,1,0 }, // = 0
{ 0,1,1,0,0,0,0 }, // = 1
182
{ 1,1,0,1,1,0,1 }, // = 2
{ 1,1,1,1,0,0,1 }, // = 3
{ 0,1,1,0,0,1,1 }, // = 4
{ 1,0,1,1,0,1,1 }, // = 5
{ 1,0,1,1,1,1,1 }, // = 6
{ 1,1,1,0,0,0,0 }, // = 7
{ 1,1,1,1,1,1,1 }, // = 8
{ 1,1,1,0,0,1,1 } // = 9
};
Em seguida, podemos criar uma função

que irá exibir o dígito desejado. Observe que
como realizamos a ligação usando
sequencialmente os pinos de 2 até 8 do Arduino,
podemos usar uma estrutura de repetição for
para acessar a matriz e ir escrevendo o valor ao
pino do Arduino relacionado, através da função
digitalWrite.

int pino = 2;
pino++;
}
}
183
Projeto 27: MEDIDOR DO NÍVEL DE

ILUMINAÇÃO
O módulo P11 – Display Simples será

utilizado em conjunto com os módulos P5 –
Extensão e P13 – LDR (ou P7 – Sensor de
Luminosidade) para exibir, em uma escala de 0 a
9, o nível de luminosidade de um determinado
local.
A primeira opção de montagem irá utilizar

os módulos P11 – Display Simples, P5 – Extensão
e P13 – LDR. Utilizando fios de conexão macho-
fêmea realize as conexões indicadas a seguir
(Figura 7.3):
a. Pino 2 do Arduino ao pino 2 do módulo P11;

i. Pino 5V do Arduino a qualquer pino +5Vcc
do P5;
j. Pino GND do módulo P13 a um dos pinos
de GND do Arduino;
k. Pino analógico A0 do Arduino ao pino Sinal
módulo P13.

184
a. Pino +5vcc do P11 a qualquer pino +5Vcc

do módulo P5;
do módulo P5.
Figura 7.3: Ligação dos Módulos P11, P13 e P5
185
Por outro lado, quando utilizar o módulo P7

– Sensor de Luminosidade em substituição ao do
módulo P13 – LDR, realize as conexões indicadas
a seguir (Figura 7.4) utilizando fios para conexão
macho-fêmea:
a. Pino 2 do Arduino ao pino 2 do módulo P11;

do P5;
j. Pino GND do módulo P7 a um dos pinos de
GND do Arduino;
k. Pino analógico A0 do Arduino ao pino Sinal
Analog. do módulo P7.


do módulo P5;
do módulo P5.
186

187
Após realizar uma das duas opções de

montagem, acesse o ambiente de
sketch:

{ 1,1,1,1,1,1,0 }, // = 0
{ 0,1,1,0,0,0,0 }, // = 1
{ 1,1,0,1,1,0,1 }, // = 2
{ 1,1,1,1,0,0,1 }, // = 3
{ 0,1,1,0,0,1,1 }, // = 4
{ 1,0,1,1,0,1,1 }, // = 5
{ 1,0,1,1,1,1,1 }, // = 6
{ 1,1,1,0,0,0,0 }, // = 7
{ 1,1,1,1,1,1,1 }, // = 8
{ 1,1,1,0,0,1,1 } // = 9
};
int LDR = A0;
void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}

int pino = 2;
188

pino++;
}
}
void limpar() {
byte pino = 2;
pino++;
}
}
void loop() {
escrever(nivel);
delay(1000);
limpar();
}
Observe que iremos utilizar a matriz

digitos e a função escreva, já desenvolvidos
anteriormente, para mostrar os dígitos no display
de LEDs. Em seguida, na função loop obtemos o
valor do LDR que consiste em um valor entre 0 e
1023 e mapeamos para um valor entre entre 0 e
9, o qual será mostrado no display, conforme
mostra o trecho de código-fonte a seguir.

escrever(nivel);
189
Projeto 28: DADO ELETRÔNICO COM

DISPLAY DE LED
Neste projeto vamos criar um dado

eletrônico usando os módulos P11 – Display
Simples, P4 – Switch e P5 – Extensão. O
funcionamento é bastante simples, toda vez que
o usuário pressionar o botão, um número entre 1
e 6 será sorteado e exibido no módulo P11 –
Display Simples.
Utilizando fios para conexão macho-fêmea

realize as conexões indicadas a seguir (Figura
7.5) para ligar os módulos e o Arduino:
a. Pino 2 do Arduino ao pino 2 do P11;

b. Pino 3 do Arduino ao pino 3 do P11;
c. Pino 4 do Arduino ao pino 4 do P11;
d. Pino 5 do Arduino ao pino 5 do P11;
e. Pino 6 do Arduino ao pino 6 do P11;
f. Pino 7 do Arduino ao pino 7 do P11;
g. Pino 8 do Arduino ao pino 8 do P11;
h. Pino 9 do Arduino ao pino 9 do P11;
do P5;
j. Pino Gnd do P4 ao pino de Gnd do Arduino;
k. Pino Out do P4 ao pino digital 11 do
Arduino.

190

do módulo P5;
do módulo P5.
191

Arduino e digite o sketch a seguir:

{ 0,1,1,0,0,0,0 }, // = 1
{ 1,1,0,1,1,0,1 }, // = 2
{ 1,1,1,1,0,0,1 }, // = 3
{ 0,1,1,0,0,1,1 }, // = 4
{ 1,0,1,1,0,1,1 }, // = 5
{ 1,0,1,1,1,1,1 }, // = 6
};
int BOTAO = 11;

int valor;
int anterior = 0;
void setup() {
randomSeed(analogRead(0));
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}

int pino = 2;
192
pino++;
}
}
void limpar() {
byte pino = 2;
pino++;
}
}
void loop() {
escrever(random(1, 7));
}
anterior = valor;
delay (50);
}
Conforme pode ser notado no sketch a

matriz digito irá conter os números de 1 a 6 e a
função escreva os irá exibir no display de LEDs.
Por outro lado, na função loop, sempre que o
botão foi pressionado sortearemos, utilizando a
função random, um número (entre 1 e 6) para
ser exibido.
193
Projeto 29: CONTADOR HEXADECIMAL
Neste projeto iremos utilizar os módulos

P11 – Display Simples e P17 – Encoder para criar
um contador hexadecimal (0, 1, 2, 3, 4, 5, 6, 7, 8,
9, A, B, C, D, E, F), de modo que o dígito exibido
no display de LED de 7 segmentos seja
incrementado ou decrementado conforme a
variação de posição da chave rotativa (encoder).
Para realizar a montagem utilize fios de

conexão macho-fêmea para realizar as conexões
indicadas a seguir (Figura 7.6):

i. Pino 5V do Arduino ao pino +5Vcc do P11;
j. Ligue o pino Sinal 1 do P17 na entrada
analógica A2 do Arduino;
k. Ligue o pino Sinal 2 do P17 na entrada
analógica A3 do Arduino;
l. Ligue o pino GND do P17 a um dos pinos de
GND do Arduino.
194
Figura 7.6: Ligação dos Módulos P11 e P17

195
#include <RotaryEncoder.h>
// Matriz com os dígitos hexadecimais (0 a F).

{ 1,1,1,1,1,1,0 }, // = 0
{ 0,1,1,0,0,0,0 }, // = 1
{ 1,1,0,1,1,0,1 }, // = 2
{ 1,1,1,1,0,0,1 }, // = 3
{ 0,1,1,0,0,1,1 }, // = 4
{ 1,0,1,1,0,1,1 }, // = 5
{ 1,0,1,1,1,1,1 }, // = 6
{ 1,1,1,0,0,0,0 }, // = 7
{ 1,1,1,1,1,1,1 }, // = 8
{ 1,1,1,0,0,1,1 }, // = 9
{ 1,1,1,0,1,1,1 }, // = A
{ 0,0,1,1,1,1,1 }, // = b
{ 1,0,0,1,1,1,0 }, // = C
{ 0,1,1,1,1,0,1 }, // = d
{ 1,0,0,1,1,1,1 }, // = E
{ 1,0,0,0,1,1,1 } // = F
};
void setup() {
Serial.begin(9600);

// Habilita a interrupção para os pinos

pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
196
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
limpar();
}
// Rotina do Serviço de Interrupção 1

// (Pin Change). Esta rotina apenas é chamada
// quando ocorre uma mudança de sinal nos pinos
// A2 e A3
ISR(PCINT1_vect) {
encoder.tick();
}

int pino = 2;
pino++;
}
}
void limpar() {
byte pino = 2;
pino++;
}
// Desligar ponto decimal:
digitalWrite(9, HIGH);
}
void loop() {
197
static int pos = 0;

int novaPos = encoder.getPosition();
if (pos != novaPos) {
Serial.println(novaPos);
pos = novaPos;
if (pos >= 0 && pos <= 15) {
limpar();
escrever(pos);
}
}
}
Observando o sketch temos que a matriz

dígitos irá conter os números hexadecimais de 0
a F. Note também a utilização do encoder através
da biblioteca RotaryEncoder abordada
anteriormente, em detalhes, no “Projeto 20:
CONTADOR BINÁRIO COM ENCODER”.
Por fim, na função loop obtemos a posição

do encoder e mostramos o respectivo digito em
notação hexadecimal.
198
Projeto 30: CONTADOR BINÁRIO E

DECIMAL
Neste projeto vamos utilizar os módulos

P11 – Display Simples, P7 – Sensor de
Luminosidade (ou P21 – Semáforo), P4 – Switch e
P5 – Extensão para criar um contador que irá
exibir os dígitos de 0 a 7 no módulo P11 e o
respectivo valor em binário nos LEDs do módulo
P7. Cada vez que o botão do módulo P4 for
pressionado o contador será incrementado.
Realize a montagem utilizando fios de

conexão macho-fêmea para realizar as ligações
indicadas a seguir (Figura 7.7):

do P5;
Arduino.
l. Pino GND do P7 a um dos pinos de GND do
Arduino;
m. Pino Led1 do P7 ao pino digital 13 do
Arduino;
199
n. Pino Led2 do P7 ao pino digital 12 do

Arduino;
o. Pino Led3 do P7 ao pino digital 11 do
Arduino.


do módulo P5;
do módulo P5.
200
Figura 7.7: Ligação dos Módulos P11, P7, P4 e P5
Também é possível montar o mesmo

projeto substituindo o módulo P7 – Sensor de
Luminosidade pelo módulo P21 – Semáforo, neste
201
caso, utilizando fios para ligação macho-fêmea,

realize as ligações indicadas a seguir (Figura 7.8):

do P5;
Arduino.
l. Pino GND do P21 a um dos pinos de GND
do Arduino;
m. Pino Led1 do P21 ao pino digital 13 do
Arduino;
n. Pino Led2 do P21 ao pino digital 12 do
Arduino;
o. Pino Led3 do P21 ao pino digital 11 do
Arduino.


do módulo P5;
do módulo P5.
202

// Contador Binário e Decimal

// Matriz com os dígitos binários de 0 a 7.
203
int binario[8][3] = {
{ LOW, LOW, LOW }, // 0
};
// Matriz com os dígitos decimais de 0 a 7.

byte decimal[8][7] = {
{ 1,1,1,1,1,1,0 }, // = 0
{ 0,1,1,0,0,0,0 }, // = 1
{ 1,1,0,1,1,0,1 }, // = 2
{ 1,1,1,1,0,0,1 }, // = 3
{ 0,1,1,0,0,1,1 }, // = 4
{ 1,0,1,1,0,1,1 }, // = 5
{ 1,0,1,1,1,1,1 }, // = 6
{ 1,1,1,0,0,0,0 } // = 7
};
int LED1 = 13;

int LED2 = 12;
int LED3 = 11;
int BOTAO = 10;
int num = 0;
int valor;
int anterior = 0;
void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
204
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}

int pino = 2;
digitalWrite(pino, !decimal[digito][seg]);
pino++;
}
}
void limpar() {
byte pino = 2;
pino++;
}
}
void loop() {
num++;
if (num > 7)
num = 0;
digitalWrite(LED1, binario[num][0]);
205
escrever(num);
}
anterior = valor;
delay (50);
}
Note no sketch que a matriz binario irá

conter a representação binária dos números de
deverão ser exibidos no módulo P7 – Sensor de
Luminosidade (ou P21 – Semáforo), enquanto
que a matriz decimal irá conter os mesmos
números, porém em notação decimal e que serão
exibidos no módulo P11 – Display Simples.
Veja na função loop que sempre que o

botão for pressionado, atualizamos o valor
(variável num) e o exibimos tanto em notação
binária:
Como também em notação decimal:
escrever(num);
206
>
Capítulo 8:
Infravermelho
Sensores de infravermelho apresentam
baixo custo e são muito úteis e versáteis. Nos
projetos deste capítulo iremos mostrar como
podemos utilizar, com facilidade, sinais de
infravermelho para detectar obstáculos e
também realizar o acionamento a distância
através de controle remoto.
207
Projeto 31: INTERRUPTOR DE

PROXIMIDADE
Neste projeto vamos utilizar o módulo P12 -

Sensor de Obstáculos (Figura 8.1) para
implementar um interruptor de proximidade.
Desta forma, não será necessário que a pessoa
toque o sensor para acender ou apagar um LED,
basta aproximar o dedo ou a mão. Lembrando
que podemos usar o módulo PL2 – First Robot, P7
– Sensor de Luminosidade ou P21 – Semáforo,
pois, todos possuem LEDs. Também é importante
salientar que esse tipo de circuito é muito útil
quando desejamos manter a pessoa “isolada” do
circuito elétrico, evitando choques indesejáveis.
Figura 8.1: Módulo P12 – Sensor de Obstáculos
O módulo P12 - Sensor de Obstáculos deverá

ser conectado ao Arduino da seguinte maneira
(Figura 8.2):
a. Conecte o pino 5+ do módulo P12 ao pino

5V do Arduino;
b. Conecte o pino GND do módulo P12 à um
dos pinos GND do Arduino;
208
c. Conecte o pino 7 do Arduino ao pino A0 do

módulo P12.
Figura 8.2: Ligação do Módulo P12 ao Arduino

pela Figura 8.3.
209
Quando optar por substituir o módulo PL2 –

First Robot pelo módulo P7 – Sensor de
Luminosidade realize as conexões mostradas na
Figura 8.4 e detalhadas a seguir, utilizando, para
isso, fios para conexão macho-fêmea:
a. Pino 5+ do P12 ao pino 5V do Arduino;

b. Pino GND do P12 a um dos pinos GND do
Arduino;
c. Pino 7 do Arduino ao pino A0 do módulo
P12;
d. Pino Led1 do P7 ao pino 13 do Arduino;
e. Pino GND do P7 a um dos pinos GND do
Arduino.
210
A terceira opção de montagem utilizará os

módulos P12 – Sensor de Obstáculos e P21 –
Semáforo. Neste caso, utilizando fios para ligação
macho-fêmea, realize as seguintes ligações
(Figura 8.5):

Arduino;
c. Pino 7 do Arduino ao pino A0 do módulo
P12;
e. Pino GND do P21 a um dos pinos GND do
Arduino.
211
Após montar o projeto, entre no ambiente

de desenvolvimento do Arduino e digite o sketch
a seguir.
int LED = 13;

int SENSOR = 7;
int valor;
void setup() {
pinMode(SENSOR, INPUT);
}
void loop() {
212
// Obter o valor do sensor, LOW ou HIGH

valor = digitalRead(SENSOR);
digitalWrite(LED, valor);
delay (100);
}
Note no sketch, que obtemos a leitura do

sensor através da função digitalRead que será
um valor digital, ou seja, 0 se não houver
obstáculo ou 1 se houver obstáculo à frente do
sensor.

em conectar o módulo P12 - Sensor de
Obstáculos há uma entrada analógica do
Arduino, observe a Figura 8.6 e, neste caso,
utilizando fios para conexão macho-fêmea,
conecte:

Arduino;
c. Pino A0 do Arduino ao pino A0 do P12.
213
Independente da opção de montagem que

foi adotada é importante salientar que as
ligações dos módulos PL2 – First Robot, P7 –
Sensor de Luminosidade e P21 – Semáforo
permanecerão exatamente as mesmas.
Em seguida, entre no ambiente de

programa.
int LED = 13;

int SENSOR = A0;
int valor;
int limiar = 300
void setup() {
Serial.begin(9600);
214
}
void loop() {
// Obter o valor do sensor (entre 0 e 1023)
valor = analogRead(SENSOR);
Serial.print("Valor: ");
Serial.println(valor);
if (valor > limiar)
else
delay (500);
}
É importante observar, neste exemplo, que

precisamos definir um valor de limiar (300) para
determinar se o LED será ou não aceso. Se
necessário, ajuste esse valor para as condições
de iluminação do ambiente e também em relação
à distância desejada.
215
Projeto 32: SEMÁFORO ACIONADO POR

PROXIMIDADE
Existe um tipo de sinal de trânsito,

normalmente utilizando em vias com bastante
trânsito de veículos e poucos pedestres, onde o
mesmo permanece sempre “verde” para o
tráfego de veículos, a menos que seja acionado
manualmente pelo pedestre, no momento em
que deseja atravessar a via. Este próximo projeto
irá realizar a implementação completa do
simulador de sinal de trânsito utilizando, para
isso, o módulo P21 – Semáforo, sendo este
acionado por um sensor de presença de
pedestre, que neste exemplo, utilizará o módulo
P12 – Sensor de Obstáculos (Figura 8.7).
Conforme ilustrado na Figura 8.8, faça a

montagem utilizando cabos de conexão macho-
fêmea para realizar as seguintes ligações:
a. Gnd do P21 ao pino de Gnd do Arduino;

b. Led1 do P21 ao pino 13 do Arduino;
216
c. Led2 do P21 ao pino 12 do Arduino;

d. Led3 do P21 ao pino 11 do Arduino;
e. Led4 do P21 ao pino 10 do Arduino;
f. Led5 do P21 ao pino 9 do Arduino;
g. Pino 5+ do P12 ao pino 5V do Arduino;
h. Pino GND do P12 a um dos pinos GND do
Arduino;
i. Pino A0 do Arduino ao pino A0 do P12.
Após realizar a montagem, entre no

digite o sketch a seguir.
int VERMV = 9;
217
int AMARV = 10;

int VERDV = 11;
int VERMP = 12;
int VERDP = 13;
int SENSOR = A0;

int valor;
void setup() {
}
void loop() {
if (valor < 500) {
delay (1000);
delay (2000);
218
delay(3000);
}
}
Neste sketch podemos notar na função

loop que, por padrão, o semáforo fica verde para
veículos e vermelho para os pedestres. Quando
ocorre a detecção de proximidade, através da
leitura da entrada analógica realizada pela
função analogRead(SENSOR), o semáforo irá
realizar os demais ciclos.
219
Projeto 33: SENSOR DE DISTÂNCIA
Neste projeto vamos utilizar os módulos

P12 – Sensor de Obstáculos (Figura 8.9) e PL2 –
First Robot (ou P21 – Semáforo) para desenvolver
um sensor de distância bastante simples.
O módulo P12 - Sensor de Obstáculos

deverá ser conectado ao Arduino da seguinte

Arduino;
c. Pino A0 do Arduino ao pino A0 do P12.
220

pela Figura 8.11.
221
Quando utilizar o módulo P21 – Semáforo, as

conexões ao Arduino deverão ser realizadas da
seguinte maneira (Figura 8.12):

Arduino;
c. Pino A0 do Arduino ao pino A0 do P12;
d. GND do P21 a qualquer pino GND do
Arduino;
e. Led1 do P21 ao pino 11 do Arduino;
f. Led2 do P21 ao pino 10 do Arduino;
g. Led3 do P21 ao pino 9 do Arduino.
222

Arduino
Em seguida, entre no ambiente de

programa.
// Sensor de distância

int SENSOR = A0;
int valor;
void setup() {
Serial.begin(9600);
}
void loop() {
int distancia = map(valor, 0, 1023, 0, 4);
switch (distancia) {
case 0:
break;
case 1:
223
break;
case 2:
break;
default:
break;
}
delay (100);
}
Neste sketch conforme algo se aproxima do

módulo P12 - Sensor de Obstáculos, nós iremos
acendendo os LEDs do módulo PL2 – First Robot
(ou P21 – Semáforo). Todos os LEDs apagados
indicam que não há objeto nas proximidades. O
LED Verde aceso indica algo distante, o Amarelo
indica um objeto à uma distância média
enquanto o LED Vermelho vai indicar um objeto
muito próximo (ou tocando) o sensor. Desta
maneira, obtemos o valor do sensor (entre 0 e
1023) e o mapeamos para um valor entre 0 e 4,
que indicará a proximidade de um objeto em
relação ao sensor, conforme podemos observar
no trecho de código-fonte a seguir.
224
225
Projeto 34: SENSOR DE DISTÂNCIA

COM INDICAÇÃO SONORA
Vamos adicionar uma nova funcionalidade

ao “Projeto 33: SENSOR DE DISTÂNCIA”,
desenvolvido anteriormente e que utilizou os
módulos P12 - Sensor de Obstáculos e PL2 – First
Robot (ou P21 – Semáforo). Além da indicação
visual, proporcionada pelos LEDs, iremos
também colocar uma indicação sonora, para isso,
vamos acrescentar o módulo P15 – Buzzer ao
projeto.
Quando optar em utilizar o módulo PL2 –

First Robot, realize as ligações da seguinte

Arduino;
c. Pino A0 do Arduino ao pino A0 do módulo
P12;
d. Pino GND do P15 a um dos pinos GND do
Arduino;
e. Pino Sinal do P15 ao pino digital 3 do
Arduino.
226

Arduino

pela Figura 8.14.
227
Quando substituir o módulo PL2 – First

Robot pelo módulo P21 – Semáforo, realize,
utilizando fios para ligação macho-fêmea as
conexões mostradas a seguir (Figura 8.15):

Arduino;
c. Pino A0 do Arduino ao pino A0 do módulo
P12;
d. Pino GND do P15 a um dos pinos GND do
Arduino;
e. Pino Sinal do P15 ao pino digital 3 do
Arduino
f. GND do P21 a qualquer pino GND do
Arduino;
g. Led1 do P21 ao pino 11 do Arduino;
h. Led2 do P21 ao pino 10 do Arduino;
i. Led3 do P21 ao pino 9 do Arduino.
228
Independente da opção de montagem

adotada acesse o ambiente de desenvolvimento
do Arduino e digite o sketch a seguir.
// Sensor de distância com indicação sonora

int BUZZER = 3;
int SENSOR = A0;
int valor;
void setup() {
Serial.begin(9600);
229
}
void loop() {
switch (distancia) {
case 0:
delay(50);
break;
case 1:
delay(150);
break;
case 2:
delay(250);
break;
default:
230
break;
}
delay (100);
}
Observe que quando comparado ao sketch

desenvolvido no “Projeto 33: SENSOR DE
DISTÂNCIA”, apenas foi acrescentada a função
tone para acionar o buzzer quando um dos LEDs
for aceso.
Note também que em função do LED que

está aceso alteramos o tempo da função delay,
de modo a alterar a frequência com que o som é
emitido.
Projeto 35: CONTROLE REMOTO
O intuito deste projeto é demonstrar a

utilização de módulo P14 – IR Receiver (Figura
8.16) que é um receptor de infravermelho. O
funcionamento do projeto é bastante simples, o
módulo P14 irá receber um sinal de um controle
remoto e, a partir do sinal que foi recebido,
iremos acender ou apagar um LED. Lembrando
que podemos usar o módulo PL2 – First Robot, P7
– Sensor de Luminosidade ou P21 – Semáforo,
pois, todos possuem LEDs.
231
Figura 8.16: Módulo P14 – IR Receiver
Utilizando fios para ligação macho-fêmea,

realize as seguintes conexões entre o módulo
P14 - IR Receiver e o Arduino (Figura 8.17):
a. Pino GND do Arduino ao pino GND do

módulo P14;
b. Pino 5V do Arduino ao pino +5Vcc do
módulo P14;
c. Pino 7 do Arduino ao pino Sinal do módulo
P14.
232
Figura 8.17: Conexão do Módulo P14 ao Arduino

pela Figura 8.18.

233
Quando optar por substituir o módulo PL2 –

First Robot pelo módulo P7 – Sensor de
Luminosidade realize as conexões mostradas na
Figura 8.19 e detalhadas em seguir utilizando,
para isso, fios para conexão macho-fêmea:
a. Qualquer pino GND do Arduino ao pino

GND do módulo P14;
módulo P14;
P14;
e. Pino Led2 do P7 ao pino 12 do Arduino;
f. Pino GND do P7 a um dos pinos GND do
Arduino.
234
A terceira opção de montagem utilizará os

módulos P14 – IR Receiver e P21 – Semáforo.
Neste caso, utilizando fios para ligação macho-
fêmea, realize as seguintes ligações (Figura
8.20):
a. Qualquer pino GND do Arduino ao pino

GND do módulo P14;
módulo P14;
P14;
e. Pino Led2 do P21 ao pino 12 do Arduino;
f. Pino GND do P21 a um dos pinos GND do
Arduino.
235

escolhida, o sketch será o mesmo, desta forma,
acesse o ambiente de desenvolvimento do
Arduino e digite o seguinte programa:
#include "IRremote.h"
int RECEPTOR = 7;
int LED = 12;
IRrecv controle(RECEPTOR);
decode_results resultado;
int estado = LOW;
236
void setup() {
Serial.begin(9600);
// Iniciar a recepção
controle.enableIRIn();
// O led conectado ao pino 13 irá piscar

// quando um sinal for recebido pelo receptor
controle.blink13(true);
}
void loop() {
if (controle.decode(&resultado)) {
if (resultado.decode_type == NEC) {
Serial.print("NEC: ");
}
else if (resultado.decode_type == SONY) {
Serial.print("SONY: ");
}
else if (resultado.decode_type == RC5) {
Serial.print("RC5: ");
}
else if (resultado.decode_type == RC6) {
Serial.print("RC6: ");
}
else if (resultado.decode_type == UNKNOWN) {
Serial.print("Desconhecido ");
}
Serial.println(resultado.value, HEX);
if (resultado.value == 0x8B7D22D) {
// Alterar e colocar o valor da tecla que
// irá apagar o LED
estado = LOW;
}
else if (resultado.value == 0x8B752AD) {
237
// Alterá e colocar o valor da tecla que

// irá acender o LED
estado = HIGH;
}
digitalWrite(LED, estado);
// Obter o próximo valor

controle.resume();
}
}
Em primeiro lugar devemos inserir a

biblioteca IRemote, pois, ela irá permitir
realizarmos a leitura e decodificação das
informações enviadas por um controle remoto.
Também devemos criar um objeto a partir da
classe IRrecv e outro a partir de
decode_results, conforme mostrado no
seguinte trecho de programa.
int RECEPTOR = 7;
Note no trecho de sketch a seguir, que na

função setup devemos habilitar a recepção de
sinais de infravermelho, através do método
enableIRIn. Opcionalmente, também podemos
habilitar, através do método blink13, um LED
conectado ao pino 13 do Arduino para piscar
238
sempre que um sinal for recebido do controle

remoto.
controle.blink13(true);
Na função loop recebemos o sinal emitido

pelo controle remoto através do método decode,
que irá carregar os dados recebidos em
resultado. A propriedade decode_type
identifica o modelo do controle remoto, conforme
podemos ver a seguir.
if (resultado.decode_type == NEC) {
Serial.print("NEC: ");
}
}
Enquanto a propriedade value obtém o

código da tecla que foi pressionada.
if (resultado.value == 0x8B7D22D) {
// Alterar e colocar o valor da tecla que
// irá apagar o LED
estado = LOW;
}
Como existem inúmeros modelos de

controle remoto é sempre importante que você
239
mapeie os valores das teclas que serão utilizadas

no sketch.
controle.resume();
Concluindo a explicação do sketch, o

método resume irá obter o próximo sinal
enviado pelo controle remoto.
240

REMOTAMENTE
O módulo P14 – IR Receiver será usado, em

conjunto com o módulo didático PL2 – First Robot
para ativar alguns efeitos nos LEDs a partir de
sinais emitidos por um controle remoto.
Utilizando fios para ligação macho-fêmea,

realize as seguintes conexões entre o módulo
P14 – IR Receiver e o Arduino (Figura 8.21):
a. Pino GND do Arduino ao pino GND do

módulo P14;
módulo P14;
P14.
241
Figura 8.21: Conexão do Módulo P14 ao Arduino

pela Figura 8.22.
242

int OLHOE = 12;

int OLHOD = 13;
int VERMELHO = 11;
int AMARELO = 10;
int VERDE = 9;
int NARIZ = 8;
int RECEPTOR = 7;
void setup() {
// Iniciar a recepção
}
void loop() {
if (resultado.value == 0x8B752AD) {
// Tecla seta para cima
243
}
else if (resultado.value == 0x8B7D02F) {
// Tecla seta para esquerda
}
else if (resultado.value == 0x8B710EF) {
// Tecla seta para direita
}
else if (resultado.value == 0x8B7D22D) {
// Tecla seta para baixo
}
else if (resultado.value == 0x8B76897) {
// Tecla Back
delay(200);
}
else if (resultado.value == 0x8B7A857) {
// Tecla OK
for (int i = 0; i < 10; i++) {
delay (100);
delay (100);
delay (100);
}
}
244
// Obter o próximo valor

controle.resume();
}
}
Note que o sketch utiliza os mesmos

conceitos abordados no “Projeto 35: CONTROLE
REMOTO”, porém, conforme determinada tecla
seja pressionada no controle remoto os LEDs do
PL2 irão realizar diferentes funções, por exemplo,
“abrir os olhos”, “abrir o olho esquerdo”, “abrir o
olho direito”, “fechar os olhos”, acender o “nariz”
e realizar um efeito sequencial.
Não se esqueça de mapear o valor das

teclas do controle remoto que você está
utilizando, pois devido aos diversos modelos de
controle remoto existentes, elas podem diferir do
exemplo mostrado.
245
246
>
Capítulo 9:
ATtiny85
O ATtiny85 (Figura 9.1) é um versátil
microcontrolador de baixo custo, que pode ser a
alternativa ideal para substituir o Arduino em
projetos relativamente simples.
Figura 9.1: ATtiny85
Quando comparado ao Arduino, que utiliza

a família de microcontroladores ATmega, o
ATtiny85 apresenta uma capacidade inferior de
memória e também de pinos de entrada e saída.
Desta forma, o ATtiny85 irá oferecer apenas 4
entradas/saídas digitais, 2 saídas PWM (Pulse
Width Modulation) e 3 entradas analógicas, como
podemos ver na Figura 9.2:
Figura 9.2: Pinagem do ATtiny85
247
Por outro lado, o ATtiny85 pode ser

programado pelo próprio ambiente de
desenvolvimento do Arduino apresentando, em
comum com o mesmo, o seguinte conjunto de
funções:
 pinMode ()
 digitalWrite ()
 digitalRead ()
 analogRead ()
 analogWrite ()
 shiftOut ()
 pulseIn ()
 millis ()
 micros ()
 delay ()
 delayMicroseconds ()
Nos projetos mostrados neste capítulo

iremos utilizar o módulo PL1 – Tiny Board (Figura
9.3) em conjunto com alguns dos módulos que já
abordamos anteriormente, para demonstrar
como programar e utilizar o ATtiny85.
248
Figura 9.3: Módulo PL1 – Tiny Board

Projeto 37: PROGRAMANDO O
ATTINY85 ATRAVÉS DO ARDUINO
O intuito deste projeto é demonstrar como

realizar a configuração do ambiente de
desenvolvimento do Arduino para suportar o
ATtiny85 e também como realizar a transferência
de um programa para o ATtiny utilizando, para
isso, o módulo PL1 – Tiny Board.
249
Figura 9.4: Conexão do PL1 ao Arduino
O primeiro passo consiste em realizar as

conexões entre o Arduino e o módulo PL1 – Tiny
Board. Para isso, conforme podemos ver na
Figura 9.4, utilize fios para ligação macho-fêmea
e realize as seguintes conexões:
a. Pino 13 do Arduino ao pino PB2 do PL1;

b. Pino 12 do Arduino ao pino PB1 do PL1;
c. Pino 11 do Arduino ao pino PB0 do PL1;
d. Pino 10 do Arduino ao pino PB5 do PL1;
e. Qualquer pino GND do Arduino ao qualquer
pino GND do PL1;
f. Pino 5V do Arduino ao qualquer pino 5V do
PL1.
250

Arduino, entre no menu “Arquivo”, escolha a
opção “Exemplos”, “11.ArduinoISP e carregue o
sketch “ArduinoISP” (Figura 9.5). Compile e
transfira o programa para o Arduino, a partir
deste momento, ele atuará como “ponte” entre o
computador e o ATtiny85.
Figura 9.5: Carregando o Sketch “ArduinoISP”

Em seguida, vamos configurar o ambiente
de desenvolvimento do Arduino adicionando
suporte para a família de microcontroladores
ATtiny. Entre no menu “Arquivo” e clique em
“Preferências”. Conforme mostra a Figura 9.6,
preencha o campo “URL Adicionais de
Gerenciadores de Placas” com o link:
251
https://raw.githubusercontent.com/damellis/attin
y/ide-1.6.x-boards-
manager/package_damellis_attiny_index.json e
clique no botão OK.
Figura 9.6: Janela de Preferências
252
Vá até o menu “Ferramentas”, selecione

“Placa” e “Gerenciador de Placas”. Identifique a
opção attiny, escolha a versão mais atual e
clique no botão “Instalar” (Figura 9.7).
Figura 9.7: Gerenciador de Placas
Após a instalação volte ao menu

“Ferramentas”, selecione “Placa” e “ATtiny”. Em
seguida, no mesmo menu “Ferramenta”,
selecione as opções “Processador: ATtiny85”,
“Clock: 8MHz (internal)” e, por último,
“Programador: Arduino as ISP”, conforme
podemos observar na Figura 9.8.
253
Figura 9.8: Configuração do Suporte ao ATtiny85
Digite o sketch a seguir e o transfira para o

ATtiny85 (de mesma forma que realizamos a
transferência de programas para o Arduino).
Porém, note que agora o Arduino está atuando
como ISP e servirá apenas como uma “ponte”
para que o programa seja gravado diretamente
no ATtiny85.
254
int LED = 0; // Pino PB0 do PL1 – Tiny Board
void setup() {
}
void loop() {
delay(100);
delay(100);
}
Com o intuito de testar o nosso sketch no

ATtiny85, após a transferência, vamos realizar as
seguintes conexões entre o PL1 – Tiny Board e o
módulo P21 – Semáforo, utilizando, para isso
cabos de conexão fêmea-fêmea (Figura 9.9):
a. Pino Led1 do P21 ao pino PB0 do PL1;

b. Pino GND do P21 ao qualquer pino GND do
PL1;
c. Conecte uma fonte de alimentação de 9V
ao PL1.
255
Figura 9.9: Conexão entre o PL1 e o P21

Com o objetivo de facilitar o teste,
podemos utilizar o próprio Arduino como
alimentação ao PL1, conforme ilustra a Figura
9.10.
256
Figura 9.10: Alimentação Através do Arduino

Neste caso, utilizando cabos de conexão
fêmea-fêmea faça as seguintes conexões:

257
b. Pino GND do P21 ao qualquer pino GND do

PL1;
Em seguida, com cabos de conexão macho-

fêmea ligue:
a. Qualquer pino GND do Arduino ao qualquer

pino GND do PL1;
b. Pino 5V do Arduino ao qualquer pino 5V do
PL1.
Após realizar as ligações e alimentar o

circuito, o Led1 do módulo P21 irá acender e
apagar, conforme o intervalo de tempo que
definimos em nosso sketch.
258
Projeto 38: SEMÁFORO COM ATTINY85
Neste projeto vamos alterar o “Projeto 5:

SEMÁFORO COMPLETO”, desenvolvimento com o
módulo P21 – Semáforo, para funcionar no
ATtiny85. Inicialmente realize os passos descritos
no “Projeto 37: PROGRAMANDO O ATTINY85
ATRAVÉS DO ARDUINO” de modo que o Arduino
atue como ISP, permitindo, desta maneira, que o
programa criado seja transferido para o ATtiny85.
Arduino digite o seguinte sketch:
// Semáforo completo com ATtiny85 e P21

// Conexões: ATtiny - P21
int VERMV = 0; // PB0 - Led1
int AMARV = 1; // PB1 - Led2
int VERDV = 2; // PB2 - Led3
int VERMP = 3; // PB3 - Led4
int VERDP = 4; // PB4 - Led5
void setup() {
}
void loop() {
259
delay(3000);
delay(1000);
delay (2000);
}
Após transferir o sketch para o ATtiny85,

desconecte o PL1 – Tiny Board do Arduino e,
utilizando fios para conexão fêmea-fêmea,

b. Pino Led2 do P21 ao pino PB1 do PL1;
c. Pino Led3 do P21 ao pino PB2 do PL1;
d. Pino Led4 do P21 ao pino PB3 do PL1;
e. Pino Led5 do P21 ao pino PB4 do PL1;
f. Pino GND do P21 ao qualquer pino GND do
PL1;
Lembre-se que a alimentação do circuito

pode ser realizada através de uma fonte de
alimentação de 9V ou ainda através do Arduino,
como já descrito anteriormente. Caso tenha
260
dúvidas, consulte o “Projeto 37: PROGRAMANDO

O ATTINY85 ATRAVÉS DO ARDUINO”.
Figura 9.11: Ligação dos Módulos PL1 e P21
261
Projeto 39: TERMOSTATO COM

ATTINY85
Utilizando o ATtiny85 iremos, com base na

temperatura obtida pelo módulo P10 – Sensor de
Temperatura, determinar se um LED deverá ou
não ser aceso. Os módulos P7 – Sensor de
Luminosidade ou P21 – Semáforo poderão ser
usados no projeto, pois ambos possuem LEDs.
Inicialmente realize os passos descritos no
“Projeto 37: PROGRAMANDO O ATTINY85
ATRAVÉS DO ARDUINO” de modo que o Arduino
atue como ISP, permitindo, desta maneira, que o
programa criado seja transferido para o ATtiny85.

Thermistor TERM (2); // A1

float temperatura;
int LED = 0;
void setup() {
}
void loop() {
if (temperatura < 25.0)
else
262
delay (2000);
}

desconecte o PL1 – Tiny Board do Arduino e
realize uma das duas opções de montagem
descritas a seguir.
Figura 9.12: Montagem dos Módulos PL1, P7 e

P10
A primeira opção irá utilizar os módulos

P10 – Sensor de Temperatura P7 – Sensor de
Luminosidade. Nesta opção de montagem,
realize as seguintes ligações (Figura 9.12):
263

PL1;
c. pino Sinal-A do P10 ao pino PB2 (A1) do
PL1;
d. Pino +5Vcc do P10 a qualquer pino +5V do
PL1;
Pino GND do P10 a qualquer pino GND do
PL1.

P21
264
A segunda opção consiste em utilizar o

módulo P10 – Sensor de Temperatura juntamente
com o módulo P21 – Semáforo, neste caso,

PL1;
c. pino Sinal-A do P10 ao pino PB2 (A1) do
PL1;
d. Pino +5Vcc do P10 a qualquer pino +5V do
PL1;
e. Pino GND do P10 a qualquer pino GND do
PL1.

utilizada, se lembre que a alimentação do circuito
pode ser realizada através de uma fonte de
alimentação de 9V ou ainda através do Arduino,
como já descrito anteriormente. Caso tenha
dúvidas, consulte o “Projeto 37: PROGRAMANDO
O ATTINY85 ATRAVÉS DO ARDUINO”.
265
Projeto 40: CONTROLE DE ESTUFA COM

O ATTINY85
Utilizando o ATtiny85 iremos, com base na

temperatura obtida pelo módulo P10 – Sensor de
Temperatura, decidir se devemos ou não acionar
a carga que está conectada ao módulo P9 – Relé
de 1 Canal (Figura 9.14).
Figura 9.14: Módulo P9 – Relé de 1 Canal
Em primeiro lugar realize os passos

descritos no “Projeto 37: PROGRAMANDO O
ATTINY85 ATRAVÉS DO ARDUINO” de modo que o
Arduino atue como ISP, permitindo, desta
maneira, que o programa criado seja transferido
para o ATtiny85.

Thermistor TERM (2); // Pino A1
266
float temperatura;
int RELE = 0;
void setup() {
pinMode(RELE, OUTPUT);
}
void loop() {
if (temperatura < 25.0) {
// Acionar o relé
digitalWrite(RELE, HIGH);
}
else {
// Desligar o relé
digitalWrite(RELE, LOW);
}
delay (2000);
}
267

P10

desconecte o PL1 – Tiny Board do Arduino e
realize a montagem descrita a seguir (Figura
9.15):
f. Pino Sinal do P9 ao pino PB0 do PL1;

g. Pino GND do P9 a qualquer pino GND do
PL1;
h. Pino +5Vcc do P9 a qualquer pino +5V do
PL1;
i. Pino Sinal-A do P10 ao pino PB2 (A1) do
PL1;
j. Pino GND do P10 a qualquer pino GND do
PL1;
k. Pino +5Vcc do P10 a qualquer pino +5V do
PL1.
A alimentação do circuito pode ser

realizada através de uma fonte de alimentação
de 9V ou ainda através do Arduino, como já
descrito anteriormente. Caso tenha dúvidas,
consulte o “Projeto 37: PROGRAMANDO O
ATTINY85 ATRAVÉS DO ARDUINO”.
268

Arduino Simples e Divertido e Simples-V3 PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Arduino Simples e Divertido e Simples-V3 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Arduino Simples e

Editoração, fotografias, ilustrações e revisão ortográfica:

Todos os direitos reservados e protegidos pela Lei 9610 de 19/02/1998. Todas as

Dados Internacionais de Catalogação na Publicação (CIP)

Impresso no Brasil / Printed in Brazil

À minha filha Franciele

Aos meus pais Maria Creyde e Manoel

Ao grande amigo Humberto pelo

Cláudio Vieira Oliveira

À minha esposa Flavia, por seu incentivo

Ao meus pais, Alberto e Célia,

E ao meu grande amigo Cláudio, pela

Humberto Augusto Piovesana Zanetti

Figura 1.1: Placa Arduino Uno R3

O Arduino Uno R3 apresenta 14 pinos que

O ambiente de programação (Figura 1.2) é

Figura 1.2: Ambiente de Desenvolvimento do

A função setup() deverá conter o código

A função loop() irá executar

que outro sketch seja carregado na memória

Os seguintes módulos da GBK Robotics

PL1 – Tiny Board PL2 – First Robot

PL3 – Dado Eletrônico P4 – Switch

P9 – Relé de 1 Canal P10 - Sensor de

P13 – LDR P14 – IR Receiver

P15 – Buzzer P17 – Encoder

P20 – LED RGB Ânodo P21 – Semáforo

Além dos módulos, os seguintes itens

1 Arduino Uno R3 (ou 1 ATtiny85

20 Cabos para 10 Cabos para

Conceitos Básicos da Linguagem

Durante todo o livro serão apresentados

Para aqueles que já conhecem alguma

Esta seção terá como objetivo apresentar

Um dos recursos mais comuns utilizados

o próprio programador faça anotações e depois

Outra particularidade da linguagem, que

As funções setup() e loop()

Em todos os projetos apresentados neste

A primeira função, a setup(), é executada

Portanto, a diferença entre as funções é

Valores considerados constantes são

 Valores da tensão do pino: HIGH é um

 Valores de estado de uso do pino: INPUT

Uma variável pode ser compreendida como

determinado pino na placa ou o valor de um

Para criar uma variável temos que definir o

O identificador é a referência desse valor,

Esses identificadores podem conter números e

Podemos criar uma variável “vazia” (sem

int numero = 10;

Em muitas situações é necessário

(demarcados por “{}”) serão executados, caso

Podem ocorrer situações em que é

Também é possível usar de maneira

É importante notar que este encadeamento

Há uma estrutura condicional que permite

qual será a variável (definida no switch) que será

Note que o início dos blocos de cada case

Em muitas situações necessitamos que um

Umas das estruturas de repetição é a

Caso precise que o bloco de comandos seja

Temos também uma estrutura de repetição