Arduino Simples e Divertido e Simples-v3

Prévia do material em texto

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..............................................227Capí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
http://www.arduino.org/
http://www.arduino.cc/
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
P9 – Relé de 1 Canal P10 - Sensor de
Temperatura
P11 – Display Simples
P12 - Sensor de
Obstáculos
P13 – LDR P14 – IR Receiver
P15 – Buzzer P17 – Encoder
19
Cláudio Vieira Oliveira e Humberto Zanetti
P20 – LED RGB Ânodo
Comum
P21 – Semáforo
20
Arduino Simples e Divertido
Além dos módulos, os seguintes itens
também serão necessários:
1 Arduino Uno R3 (ou
qualquer outro modelo
do Arduino)
1 ATtiny85
20 Cabos para
conexão macho-fêmea
10 Cabos para
conexão fêmea-fêmea
21
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
o próprio programador faça anotações e depois
as leia. Será muito comum durante o livro nos
depararmos com linhas assim:
23
Cláudio Vieira Oliveira e Humberto Zanetti
// 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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
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
an
Possui apenas o valor Verdadeiro (TRUE) ou 
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
g
Strings representam um conjunto ou cadeia 
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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
(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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
 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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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 decontagem 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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
++ 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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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
>
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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 nestecapítulo.
41
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
// 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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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.
Figura 2.7: Ligação do Módulo PL2 – First Robot
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
Cláudio Vieira Oliveira e Humberto Zanetti
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.
Figura 2.8: Conexão do Módulo P21 – Semáforo
48
Arduino Simples e Divertido
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(AMAR, LOW); 
 digitalWrite(VERD, HIGH); 
 delay(3000);
 digitalWrite(VERM, LOW); 
 digitalWrite(AMAR, HIGH); 
 digitalWrite(VERD, LOW); 
 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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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.
Figura 2.9: Ligação do Módulo PL2 – First Robot
51
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
(Figura 2.11) for utilizado 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.
Figura 2.11: Conexão do Módulo P21 – Semáforo
53
Cláudio Vieira Oliveira e Humberto Zanetti
Independente do módulo utilizado na
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); 
 pinMode(LED2, OUTPUT); 
 pinMode(LED3, OUTPUT); 
}
void loop() { 
 digitalWrite(LED1, HIGH); 
 digitalWrite(LED2, LOW); 
 digitalWrite(LED3, LOW); 
 delay(200);
 
 digitalWrite(LED1, LOW); 
 digitalWrite(LED2, HIGH); 
 digitalWrite(LED3, LOW); 
 delay(200);
 
 digitalWrite(LED1, LOW); 
 digitalWrite(LED2, LOW); 
 digitalWrite(LED3, HIGH); 
 delay(200);
 
 digitalWrite(LED1, LOW); 
54
Arduino Simples e Divertido
 digitalWrite(LED2, HIGH); 
 digitalWrite(LED3, LOW); 
 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
Cláudio Vieira Oliveira e Humberto Zanetti
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
menos
significativo e
deve ficar à
direita, o Led2
ocupa a posição
central, enquanto
o Led1 é o mais
significativo
ficando localizado
à esquerda.
56
Núme
ro
Led
1
Led
2
Led
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
7 High High High
Arduino Simples e Divertido
Figura 2.12: Ligação do Módulo PL2 – First Robot
A montagem, bastantesimples, 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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Outra possibilidade de montagem consiste
em substituirmos o módulo PL2 – First Robot pelo
módulo P21 – Semáforo (Figura 2.14). Neste caso
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.
58
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
int LED2 = 10;
int LED3 = 9;
int num = 0;
void setup() {
 pinMode(LED1, OUTPUT);
 pinMode(LED2, OUTPUT);
 pinMode(LED3, OUTPUT);
}
void loop() {
 digitalWrite(LED1, digito[num][0]);
 digitalWrite(LED2, digito[num][1]);
 digitalWrite(LED3, digito[num][2]);
 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:
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
60
Arduino Simples e Divertido
 { HIGH, HIGH, HIGH } // 7
};
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() {
 digitalWrite(LED1, digito[num][0]);
 digitalWrite(LED2, digito[num][1]);
 digitalWrite(LED3, digito[num][2]);
 num++;
 if (num > 7)
 num = 0;
 delay (1000);
}
61
Cláudio Vieira Oliveira e Humberto Zanetti
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):
a. Gnd do módulo ao pino de Gnd do
Arduino;
b. Led1 do módulo ao pino 9 do Arduino;
c. Led2 do módulo ao pino 10 do 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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
 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(AMARV, LOW);
 digitalWrite(VERDV, HIGH);
 digitalWrite(VERMP, HIGH);
 digitalWrite(VERDP, LOW);
 delay(1000);
 digitalWrite(VERMV, LOW);
 digitalWrite(AMARV, HIGH);
 digitalWrite(VERDV, LOW);
 digitalWrite(VERMP, HIGH);
 digitalWrite(VERDP, LOW);
 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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
 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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
A função tone(BUZZER, 1200) irá fazer
com que o buzzer reproduza a frequênciade
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() { 
 pinMode(BUZZER, OUTPUT);
}
70
Arduino Simples e Divertido
 
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() { 
 pinMode(BUZZER, OUTPUT);
}
 
void loop() {
 for (int i = 0; i < numNotas; i++) {
 tone(BUZZER, notas[i]);
71
Cláudio Vieira Oliveira e Humberto Zanetti
 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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
Figura 2.20: Ligação do Módulo PL2 – First Robot
Agora inicie o ambiente de
desenvolvimento do Arduino e digite o sketch
(programa) a seguir:
// 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); 
 pinMode(BUZZER, OUTPUT);
74
Arduino Simples e Divertido
 i = 0;
}
 
void loop() {
 digitalWrite(OLHOE, HIGH);
 digitalWrite(OLHOD, HIGH);
 digitalWrite(LED[i], HIGH);
 // Define o pino, a frequência e a duração:
 tone(BUZZER, 5800, 100);
 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
Cláudio Vieira Oliveira e Humberto Zanetti
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
>
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
 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
Arduino Simples e Divertido
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).
Figura 3.3: 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 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
Cláudio Vieira Oliveira e Humberto Zanetti
Figura 3.4: Ligação Módulo P7 – Sensor de
Luminosidade
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 3.5).
80
Arduino Simples e Divertido
Figura 3.5: Conexão do Módulo P21 – Semáforo
Independente do módulo utilizado na
montagem o sketch (programa) é exatamente o
mesmo. Desta forma, acesse o ambiente de
desenvolvimento do Arduino e digite o sketch a
seguir:
// Exemplo de entrada de dados serial
int LED = 13;
int entrada = 0;
void setup() {
 Serial.begin(9600);
 pinMode(LED, OUTPUT);
 Serial.println("Digite 1 para acender o led ou 0 para
apagar:");
}
void loop() {
81
Cláudio Vieira Oliveira e Humberto Zanetti
 if (Serial.available() > 0) {
 // Ler o byte que está na entrada serial
 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')
 digitalWrite(LED, LOW);
 else if (entrada == '1')
 digitalWrite(LED, HIGH); 
 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 verificamosse
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
Arduino Simples e Divertido
Projeto 9: CONTROLANDO O ROBÔ
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.
Figura 3.6: Ligação do Módulo PL2 – First Robot
Em seguida, acesse o ambiente de
desenvolvimento do Arduino e digite o sketch a
seguir:
83
Cláudio Vieira Oliveira e Humberto Zanetti
// 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(OLHOE, OUTPUT);
 pinMode(OLHOD, OUTPUT);
 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() {
 if (Serial.available() > 0) {
 // Ler o byte que está na entrada serial
 entrada = Serial.read();
 switch (entrada) {
 case '1':
 digitalWrite(OLHOE, HIGH);
 digitalWrite(OLHOD, HIGH);
84
Arduino Simples e Divertido
 break;
 case '2':
 digitalWrite(OLHOE, LOW);
 digitalWrite(OLHOD, LOW);
 break;
 case '3':
 digitalWrite(OLHOE, HIGH);
 break;
 case '4':
 digitalWrite(OLHOD, HIGH);
 break;
 case '5':
 for (int i = 0; i < 5; i++) {
 digitalWrite(OLHOE, LOW);
 delay (100);
 digitalWrite(OLHOE, HIGH);
 delay (100);
 }
 break;
 case '6':
 for (int i = 0; i < 5; i++) {
 digitalWrite(OLHOD, LOW);
 delay (100);
 digitalWrite(OLHOD, HIGH);
 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
Cláudio Vieira Oliveira e Humberto Zanetti
 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
Arduino Simples e Divertido
87
Cláudio Vieira Oliveira e Humberto Zanetti
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
>
Arduino Simples e Divertido
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.
Figura 4.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 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
Cláudio Vieira Oliveira e Humberto Zanetti
Figura 4.3: Ligação Módulo P7 – Sensor de
Luminosidade
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 11 do Arduino ao Pino
Led1 do módulo P21 (Figura 4.4).
90
Arduino Simples e Divertido
Figura 4.4: Conexão do Módulo P21 – Semáforo
Independente do módulo utilizado na
montagem o sketch (programa) é exatamente o
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() {
 pinMode(LED, OUTPUT);
}
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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
Figura 4.5: Conexões do Módulo PL2 – First Robot
Após realizar a montagem, acesse o
ambiente de desenvolvimento do Arduino e
digite o seguinte sketch:
// Robô com Sono 
int OLHOD = 11;
int OLHOE = 10;
float seno;
int intensidade;
void setup() {
 Serial.begin(9600);
 pinMode(OLHOD, OUTPUT);
 pinMode(OLHOE, OUTPUT);
}
void loop() {
 for (int i = 0; i < 180; i++) {
 seno = sin(i * (3.1416 / 180));
94
Arduino Simples e Divertido
 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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
Figura 4.7: Ligação do P20 ao Arduino
Após realizar a montagem, acesse o
ambiente de desenvolvimento do Arduino e
digite o seguinte sketch:
// 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
Cláudio Vieira Oliveira e Humberto Zanetti
 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
Arduino Simples e Divertido
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
>
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
Figura 5.2: Conexão do Módulo P4 – Switch
Em seguida, encaixe o módulo PL2 – First
Robot diretamente no Arduino conforme ilustrado
pela Figura 5.3.
Figura 5.3: Ligação do Módulo PL2 – First Robot
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
Cláudio Vieira Oliveira e Humberto Zanetti
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 Simples e Divertido
Figura 5.5: Ligação dos Módulos P21 e P4 ao
Arduino
Independente do módulo utilizado na
montagem o sketch (programa) é exatamente o
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:
// Botão Liga-Desliga
int LED = 13; 
int BOTAO = 2;
int valor;
void setup() { 
 pinMode(LED, OUTPUT);
 pinMode(BOTAO, INPUT);
}
103
Cláudio Vieira Oliveira e Humberto Zanetti
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() {
 pinMode(LED, OUTPUT);
 pinMode(BOTAO, INPUT);
}
104
Arduino Simples e Divertido
void loop() {
 valor = digitalRead(BOTAO);
 if (valor == HIGH && anterior == LOW) {
 estado = !estado;
 }
 digitalWrite(LED, estado);
 anterior = valor;
 delay (50);
} 
105
Cláudio Vieira Oliveira e Humberto Zanetti
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ô. 
Figura 5.6: Módulo P4 – Switch
Utilizando fios de conexão Macho-Fêmea
ligue o módulo P4 – Switch ao Arduino (Figura
5.7) 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.
106
Arduino Simples e Divertido
Figura 5.7: Conexão do Módulo P4 – Switch
Em seguida, encaixe o módulo PL2 – First
Robot diretamente no Arduino conforme ilustrado
pela Figura 5.8.
Figura 5.8: Ligação do Módulo PL2 – First Robot
107
Cláudio Vieira Oliveira e Humberto Zanetti
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() {
 pinMode(OLHOE, OUTPUT);
 pinMode(OLHOD, OUTPUT);
 pinMode(VERMELHO, OUTPUT);
 pinMode(AMARELO, OUTPUT);
 pinMode(VERDE, OUTPUT);
 pinMode(NARIZ, OUTPUT);
 pinMode(BOTAO, INPUT);
}
void loop() {
 botao = digitalRead(BOTAO);
 if (botao == HIGH && anterior == LOW) {
 funcao++;
 switch (funcao) {
 case 1:
 digitalWrite(OLHOE, HIGH);
 digitalWrite(OLHOD, HIGH);
 break;
108
Arduino Simples e Divertido
 case 2:
 digitalWrite(OLHOE, HIGH);
 digitalWrite(OLHOD, LOW);
 break;
 case 3:
 digitalWrite(OLHOE, LOW);
 digitalWrite(OLHOD, HIGH);
 break;
 case 4:
 for (int i = 0; i < 5; i++) {
 digitalWrite(OLHOE, LOW);
 delay (100);
 digitalWrite(OLHOE, HIGH);
 delay (100);
 }
 break;
 case 5:
 for (int i = 0; i < 5; i++) {
 digitalWrite(OLHOD, LOW);
 delay (100);
 digitalWrite(OLHOD, HIGH);
 delay (100);
 }
 break;
 case 6:
 digitalWrite(NARIZ, HIGH);
 delay(200);
 digitalWrite(NARIZ, LOW);
 break;
 case 7:
 for (int i = 0; i < 10; i++) {
 digitalWrite(VERMELHO, HIGH);
 delay (100);
 digitalWrite(VERMELHO, LOW);
 digitalWrite(AMARELO, HIGH);
 delay (100);
 digitalWrite(AMARELO,LOW);
109
Cláudio Vieira Oliveira e Humberto Zanetti
 digitalWrite(VERDE, HIGH);
 delay (100);
 digitalWrite(VERDE, LOW);
 }
 break;
 default:
 digitalWrite(OLHOE, LOW);
 digitalWrite(OLHOD, LOW);
 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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
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
Arduino Simples e Divertido
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
Cláudio Vieira Oliveira e Humberto Zanetti
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() { 
 pinMode(LED1, OUTPUT);
 pinMode(LED2, OUTPUT);
 pinMode(LED3, OUTPUT);
 pinMode(LED4, OUTPUT);
 pinMode(LED5, OUTPUT);
 pinMode(LED6, OUTPUT);
 pinMode(LED7, OUTPUT);
 pinMode(BOTAO, INPUT);
}
void loop() { 
 botao = digitalRead(BOTAO);
 if (botao == HIGH && anterior == LOW) {
 contador++;
114
Arduino Simples e Divertido
 if (contador > 6)
 contador = 0;
 mostrarDado(contador);
 }
 anterior = botao;
 delay (50);
}
void mostrarDado(int valor) {
 if (valor == 0) {
 digitalWrite(LED1, LOW);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, LOW);
 digitalWrite(LED4, LOW);
 digitalWrite(LED5, LOW);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, LOW);
 }
 else if (valor == 1) {
 digitalWrite(LED1, LOW);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, LOW);
 digitalWrite(LED4, HIGH);
 digitalWrite(LED5, LOW);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, LOW);
 }
 else if (valor == 2) {
 digitalWrite(LED1, HIGH);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, LOW);
 digitalWrite(LED4, LOW);
 digitalWrite(LED5, HIGH);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, LOW);
 }
 else if (valor == 3) {
115
Cláudio Vieira Oliveira e Humberto Zanetti
 digitalWrite(LED1, LOW);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, HIGH);
 digitalWrite(LED4, HIGH);
 digitalWrite(LED5, LOW);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, HIGH);
 }
 else if (valor == 4) {
 digitalWrite(LED1, HIGH);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, HIGH);
 digitalWrite(LED4, LOW);
 digitalWrite(LED5, HIGH);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, HIGH);
 }
 else if (valor == 5) {
 digitalWrite(LED1, HIGH);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, HIGH);
 digitalWrite(LED4, HIGH);
 digitalWrite(LED5, HIGH);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, HIGH);
 }
 else if (valor == 6) {
 digitalWrite(LED1, HIGH);
 digitalWrite(LED2, HIGH);
 digitalWrite(LED3, HIGH);
 digitalWrite(LED4, LOW);
 digitalWrite(LED5, HIGH);
 digitalWrite(LED6, HIGH);
 digitalWrite(LED7, HIGH);
 }
}
116
Arduino Simples e Divertido
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
Utilizando fios para conexão Macho-Fêmea
ligue o módulo PL3 – Dado Eletrônico (Figura
5.12) da seguinte maneira:
a. Pino Gnd do PL3 ao pino de Gnd do
Arduino;
b. Pino +5vcc do PL3 ao pino 5 Volts do
Arduino;
117
Cláudio Vieira Oliveira e Humberto Zanetti
c. Pino Switch do PL3 ao pino digital 2 do
Arduino;
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.
Figura 5.12: Ligação do Módulo PL3 – Dado
Eletrônico
118
Arduino Simples e Divertido
Acesse o ambiente de desenvolvimento do
Arduino e digite o sketch a seguir:
// 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;
void setup() {
 randomSeed(analogRead(A0));
 pinMode(LED1, OUTPUT);
 pinMode(LED2, OUTPUT);
 pinMode(LED3, OUTPUT);
 pinMode(LED4, OUTPUT);
 pinMode(LED5, OUTPUT);
 pinMode(LED6, OUTPUT);
 pinMode(LED7, OUTPUT);
 pinMode(BOTAO, INPUT);
}
void loop() {
 botao = digitalRead(BOTAO);
119
Cláudio Vieira Oliveira e Humberto Zanetti
 if (botao == HIGH && anterior == LOW) {
 // 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) {
 digitalWrite(LED1, LOW);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, LOW);
 digitalWrite(LED4, LOW);
 digitalWrite(LED5, LOW);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, LOW);
 }
 else if (valor == 1) {
 digitalWrite(LED1, LOW);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, LOW);
 digitalWrite(LED4, HIGH);
 digitalWrite(LED5, LOW);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, LOW);
 }
 else if (valor == 2) {
 digitalWrite(LED1, HIGH);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, LOW);
120
Arduino Simples e Divertido
 digitalWrite(LED4, LOW);
 digitalWrite(LED5, HIGH);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, LOW);
 }
 else if (valor == 3) {
 digitalWrite(LED1, LOW);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, HIGH);
 digitalWrite(LED4, HIGH);
 digitalWrite(LED5, LOW);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, HIGH);
 }
 else if (valor == 4) {
 digitalWrite(LED1, HIGH);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, HIGH);
 digitalWrite(LED4, LOW);
 digitalWrite(LED5, HIGH);
 digitalWrite(LED6, LOW);
 digitalWrite(LED7, HIGH);
 }
 else if (valor == 5) {
 digitalWrite(LED1, HIGH);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, HIGH);
 digitalWrite(LED4, HIGH);
 digitalWrite(LED5, HIGH);
 digitalWrite(LED6, LOW);