KIT INICANTE ARDUINO

Um guia básico para começar a entender um pouco deste universo IOT.

 Parabéns por adquirir o Kit Iniciante em eletrônica aplicada a plataforma Arduino da
Multipeças Curitiba.
O material apresentado a seguir, é uma coletânea de dados referentes a utilização de
componentes eletrônicos aplicados a experimentos com a plataforma Arduino; tendo esta como
base para o desenvolvimento das ideias propostas; adquirindo todo um manancial de
conhecimento.
A concepção deste kit, é fruto do desenvolvimento e crescimento da cultura representada
pelo movimento Maker que difunde ao máximo o conceito “faça você mesmo” (DIY – do it yourself,
em inglês). Logo, a nossa proposta é promover o estímulo de pessoas comuns para que explorem
sua criatividade e possam desenvolver soluções. A cultura Maker se nutre da iniciativa de construir,
consertar, modificar ou fabricar suas próprias coisas. Os adeptos deste movimento são conhecidos
como Makers ou fazedores.

Com esta visão e nesses novos tempos de acesso fácil a informação e à eletrônica, que o
kit foi desenvolvido e com este guia; mostraremos diversas possibilidades do mundo da eletrônica
e programação. Com isso, queremos incentivar o posterior estudo dedicado em cada área, seja em
desenvolvimento de programas, eletrônica, engenharias etc.

Neste guia você irá aprender o básico sobre mundo Maker, Arduíno, eletrônica e
programação, desenvolvendo 15 projetos práticos. Se você não domina a área, não se assuste,
nesse guia você irá encontrar as instruções de montagem e a programação para cada projeto.

No Kit Arduíno, estão inclusos diversos desses sensores e módulos. Além dos itens do kit,
você vai precisar de acesso a um computador para programar a sua placa, acesso à internet para
ver os outros projetos do guia e baixar a IDE e algumas horas de dedicação. Ao decorrer dos 15
projetos você irá aprender como utilizar esses módulos e sensores em conjunto com o Arduíno. Se
você encontrar dificuldade em algum dos projetos, faça uma nova leitura das instruções e verifique
os possíveis erros e soluções em cada projeto.

Ao final deste guia, o nosso intuito é que o usuário tenha desenvolvido novas habilidades
no campo do raciocínio lógico; noções gerais de eletrônica e programação. Sendo primeiro contato
com este universo Maker ou com a eletrônica propriamente dita, desejamos que você tenha uma
excelente viajem por esta nova estrada de conhecimento aqui apresentada.

Aproveite muito!!!!

Equipe Multipeças Curitiba

1
O QUE É O ARDUINO.............................................................................................................................................. 5
O CONCEITO DE OPEN HARDWARE ................................................................................................................ 7
ARDUINO UNO R3 ........................................................................................................................................................ 8
FAMÍLIA ARDUINO..................................................................................................................................................... 10
BAIXANDO E INSTALANDO A IDE ARDUINO ..................................................................................... 11
ESTRUTURA DE UM PROGRAMA ARDUÍNO ......................................................................................... 14
CARREGANDO UM PROGRAMA NO ARDUINO .................................................................................. 16
PRIMEIRO PROJETO – PISCA PISCA............................................................................................................. 18
- MATERIAL NECESSÁRIO ............................................................................................................................. 19
- COMO FUNCIONA A PROTOBOARD? ................................................................................................ 19
- O QUE É UM LED? ............................................................................................................................................. 20
- O QUE É UM RESISTOR? ............................................................................................................................... 22
- O QUE É UM JUMPER? .................................................................................................................................... 23
- COMO FUNCIONA UM CIRCUITO ELETRÔNICO? ..................................................................... 23
- MONTAGEM DO CIRCUITO ...................................................................................................................... 24
- PROGRAMANDO O PROJETO PISCA PISCA ................................................................................... 26
- POSSÍVEIS ERROS ............................................................................................................................................. 28
SEGUNDO PROJETO – S.O.S. LUMINOSO ................................................................................................ 29
- MATERIAL NECESSÁRIO ............................................................................................................................. 29
- MONTAGEM DO CIRCUITO ...................................................................................................................... 30
- PROGRAMANDO O PROJETO S.O.S COM LED.............................................................................. 30
- POSSÍVEIS ERROS ............................................................................................................................................. 31
TERCEIRO PROJETO – BRILHO OSCILANTE ......................................................................................... 32
- MATERIAL NECESSÁRIO ............................................................................................................................. 32
- MONTAGEM DO CIRCUITO ...................................................................................................................... 32
- PROGRAMANDO O PROJETO BRILHO OSCILANTE ................................................................. 33
QUARTO PROJETO - SEMÁFORO.................................................................................................................. 35
- MATERIAL NECESSÁRIO ............................................................................................................................. 35
- MONTAGEM DO CIRCUITO ...................................................................................................................... 36
- PROGRAMANDO O PROJETO SEMÁFORO ...................................................................................... 36
- POSSÍVEIS ERROS ............................................................................................................................................. 38
QUINTO PROJETO – INTERRUPTOR DE LUZ ....................................................................................... 39

2
 - MATERIAL NECESSÁRIO ............................................................................................................................ 40
- MONTAGEM DO CIRCUITO ...................................................................................................................... 40
- PROGRAMANDO O PROJETO INTERRUPTOR DE LUZ ........................................................... 41
SEXTO PROJETO – LUZES COLORIDAS ................................................................................................... 43
- MATERIAL NECESSÁRIO ............................................................................................................................. 44
- MONTAGEM DO CIRCUITO ...................................................................................................................... 44
- PROGAMANDO O PROJETO LUZES COLORIDAS ...................................................................... 45
- POSSÍVEIS ERROS ............................................................................................................................................. 46
SÉTIMO PROJETO – TROCANDO A COR DAS LUZES ..................................................................... 47
- MATERIAL NECESSÁRIO ............................................................................................................................. 48
- MONTAGEM DO CIRCUITO ...................................................................................................................... 48
- PROGRAMANDO O PROJETO TROCANDO A COR DAS LUZES ....................................... 49
- POSSÍVEIS ERROS ............................................................................................................................................. 51
OITAVO PROJETO – ACIONANDO UM MOTOR.................................................................................. 52
- MATERIAL NECESSÁRIO ............................................................................................................................. 53
- MONTAGEM DO CIRCUITO ...................................................................................................................... 53
- PROGRAMANDO O PROJETO ACIONANDO UM MOTOR..................................................... 54
- POSSÍVEIS ERROS ............................................................................................................................................. 55
NONO PROJETO – CONTROLANDO UM MOTOR ............................................................................. 56
- MATERIAL NECESSÁRIO ............................................................................................................................. 56
- MONTAGEM DO CIRCUITO ...................................................................................................................... 56
- PROGRAMANDO O PROJETO CONTROLANDO O MOTOR ................................................ 57
- POSSÍVEIS ERROS ............................................................................................................................................. 58
DÉCIMO PROJETO – SENSOR DE LUZ AMBIENTE ............................................................................. 59
- MATERAL NECESSÁRIO ............................................................................................................................... 60
- MONTAGEM DO CIRCUITO ...................................................................................................................... 60
- PROGRAMANDO O PROJETO SENSOR DE LUZ ........................................................................... 61
- POSSÍVEIS ERROS ............................................................................................................................................. 62
DÉCIMO PRIMEIRO PROJETO – DÓ RÉ MI ................................................................................................ 63
- MATERIAL NECESSÁRIO ............................................................................................................................. 63
- MONTAGEM DO CIRCUITO ...................................................................................................................... 64
- PROGRAMANDO O PROJETO DÓ RÉ MI ........................................................................................... 64
- POSSÍVEIS ERROS ............................................................................................................................................. 65
DÉCIMO SEGUNDO PROJETO – ALARME A LASER ........................................................................... 66
- MATERIAL NECESSÁRIO ............................................................................................................................. 67
- MONTAGEM DO CIRCUITO ...................................................................................................................... 67

3
 - PROGRAMANDO O PROJETO ALARME A LASER ........................................................................ 68
- POSSÍVEIS ERROS ............................................................................................................................................. 69
DÉCIMO TERCEIRO PROJETO – ALARME DE MOVIMENTO ........................................................ 70
- MATERIAL NECESSÁRIO ............................................................................................................................. 71
- MONTAGEM DO CIRCUITO ...................................................................................................................... 71
- POSSÍVEIS ERROS ............................................................................................................................................. 72
DÉCIMO QUARTO PROJETO – CONTADOR DIGITAL..................................................................... 73
- MATERIAL NECESSÁRIO ............................................................................................................................. 74
- MONTAGEM DO CIRCUITO ...................................................................................................................... 75
- PROGRAMANDO O PROJETO CONTADOR DIGITAL............................................................... 75
- POSSÍVEIS ERROS ............................................................................................................................................. 79
DÉCIMO QUINTO PROJETO – DADO ELETRÔNICO ........................................................................ 80
- MATERIAL NECESSÁRIO ............................................................................................................................. 80
- MONTAGEM DO CIRCUITO ...................................................................................................................... 80
- PROGRAMANDO O PROJETO DADO ELETRÔNICO ................................................................. 81
- POSSÍVEIS ERROS ............................................................................................................................................. 85
CONCLUSÃO .............................................................................................................................................................. 86

4
 O QUE É O ARDUINO

Você já deve estar se perguntando como tornar a eletrônica e a programação acessíveis e de

fácil entendimento para pessoas sem conhecimento técnico ou sem formação em Engenharia? Foi
aí que surgiu o Arduíno e deixou tudo mais simples.

O Arduíno é a principal plataforma de prototipagem eletrônica e está amplamente difundida

no mundo. Desenvolvedores, engenheiros, estudantes, empresas e Makers em geral estão
utilizando Arduíno para inovar em seus projetos dos mais variados tipos. Existem diversas placas
de Arduíno, mas neste guia vamos trabalhar apenas com a mais simples delas, a Arduíno Uno.
Este equipamento, pode adquirir informação do ambiente através de seus pinos de entrada,
para isso uma completa gama de sensores pode ser usada. Por outro lado, o Arduino pode atuar
no ambiente controlando luzes, motores ou outros atuadores.
Os campos de atuação para o controle de sistemas são imensos, podendo ter aplicações
na área de impressão 3D, robótica, engenharia de transportes, engenharia agronômica, musical,
moda e tantas outras.
O projeto Arduino começou no ano de 2005 com o objetivo de criar um dispositivo para
estudantes que oferecesse controle integrado de projetos de design e interação, e que fosse mais
econômico que os sistemas de criação de protótipos disponíveis até o momento.
O que chamamos hoje de Arduino (o microcontrolador) nasceu na cidade italiana de Ivrea.
Nesta mesma cidade nos séculos X e XI houve um outro Arduino (um nobre) que se auto proclamou
rei de toda a Itália, obviamente a coisa não funcionou e, como era comum na época, ele foi morto
pelos rivais. O fato é que em sua cidade natal ele ainda é muito lembrado, a avenida principal da
cidade se chama “Via Arduino” bem como muitos comércios locais.

5
 Enquanto viviam lá, os integrantes do time que criou o Arduino (o microcontrolador), depois
do expediente iam tomar uma cerveja. Onde? No Bar Arduino. Assim o nome do Arduino (o
microcontrolador) é uma homenagem ao Arduino (o bar) que por sua vez era uma homenagem ao
outro Arduino (o nobre).
O projeto Arduino foi desenvolvido por Massimo Banzi, David Cuartielles, Tom Igoe,
Gianluca Martino e David Mellis. Está baseado em uma plataforma de código aberta chamada
Wiring, criada pelo artista colombiano Hernando Barragán durante uma tese de um master no
Interaction Design Institute Ivrea. Por outro lado, Wiring está baseado em Processing e seu entorno
de desenvolvimento integrado foi criado por Casey Reas e Ben Fry.
A ideia do nosso Kit Arduino Iniciante, é ajudar quem está começando no mundo da
eletrônica. Neste kit você vai encontrar tudo o que precisa para dar seus primeiros passos e
desenvolver projetos utilizando um dos hardwares mais versáteis do mundo da eletrônica!
O Arduíno Uno tem um microcontrolador que é o “cérebro” da placa e é ele que
programamos para realizar os nossos projetos. Além do microcontrolador, a placa possui diversas
entradas e saídas e pode ser facilmente conectada ao computador através de um cabo USB.
Para programar o Arduino, utilizamos um programa chamado IDE (Integrated Development
Environment, ou Ambiente de Desenvolvimento Integrado).

As entradas e saídas do Arduíno são esses vários pinos, mais comumente chamados de
portas. É através dos pinos que a placa interage com os outros componentes. O microcontrolador vai
receber e enviar comandos através dessas portas de acordo com o que foi definido em sua
programação.

Depois de programada, a placa Arduíno pode ser usada de forma independente, sem a
necessidade de um computador. O programa fica salvo na placa e basta você fornecer energia para
ele funcionar, colocando o cabo USB do Arduíno em um carregador de celular, por exemplo.

Ou seja, você pode colocá-la para controlar um robô, um ventilador, as luzes da sua casa, a
temperatura do ar condicionado ou pode utilizá-la como um aparelho de medição. Existem diversos
sensores e módulos que podem ser usados em conjunto com Arduíno para expandir suas funções,
assim você pode desenvolver qualquer projeto que vier à cabeça.

No próximo tópico, iremos citar uma dúvida muito recorrente entre os hobistas Makers a
respeito da origem das placas Arduíno.

6
 O CONCEITO DE OPEN HARDWARE

Apesar de ser um conceito aparentemente simples, o conceito de Open Hardware ainda

confunde muita gente, que costuma associar esse tipo de hardware à pirataria.

O conceito de Open Hardware é muito parecido com o conceito de software livre,

popularizado pelo sistema operacional Linux, cujo código fonte é aberto, ou seja, você pode baixar
o código, fazer as suas próprias modificações e criar um Linux customizado.

Com o Open Hardware acontece praticamente a mesma coisa. São circuitos eletrônicos ou
hardware de computador que podem ser copiados livremente, já que o próprio desenvolvedor
disponibiliza o diagrama esquemático, lista de componentes, layout de placa e outras informações
relacionadas ao hardware.

Geralmente o desenvolvedor não cobra nenhuma taxa de licença, mas em alguns casos é
exigido que o nome dele seja incluído nos créditos do projeto final. O desenvolvedor também pode
exigir que qualquer projeto baseado em seu trabalho seja distribuído no esquema de Open
Hardware.

Redução de custos talvez seja a primeira coisa que venha à cabeça quando se pensa em
Open Hardware. Afinal, um fabricante pode por exemplo encomendar milhões de componentes ao
mesmo tempo, obter um desconto junto aos fornecedores e repassar esse desconto ao preço final
do produto.

Mas outra grande vantagem é a possibilidade de melhorar o hardware, acrescentando alguma

funcionalidade extra ou até mesmo resolvendo algum problema de funcionamento no hardware
original.

Pensando em termos genéricos, imagine uma empresa que deseja monitorar centenas de
máquinas utilizando uma placa com microcontrolador e comunicação via rede WiFi. Ao invés de
conectar vários componentes via cabos, shields e conectores, ela pode simplesmente optar por
montar o seu próprio hardware com todos os componentes necessários, sem perder as
características básicas do hardware original. Terá uma solução com menor custo e também com
menor possibilidade de ocorrência de falhas.

Open Hardware é frequentemente confundido com pirataria, mas são conceitos

completamente distintos. Vamos tomar como exemplo o Arduíno. Um fabricante pode colocar em
uma mesma placa um ATmega, o regulador de tensão, o chip FTDI, os demais componente e criar
seu próprio Arduíno.

O que ele não pode é utilizar o nome Arduíno, o logo e a frase “Made in Italy”, principalmente
se ele não foi produzido lá, certo? Nesse caso, estaria caracterizada a pirataria.

7
 ARDUINO UNO R3

Atualmente no mercado, devido a uma questão de viabilidade financeira; temos dois

modelos de placa Arduino Uno R3: a placa com o processador tipo “DIP” e a placa com o
processador tipo “SMD”. As duas placas possuem a mesma funcionabilidade, tanto na quantidade
de portas de comunicação; quanto na capacidade de memória; etc...

Conversor Serial/USB- Chip responsável

pela conversão e comunicação entre o
computador e o Arduino, possibilitando o
upload do código binário criado e gerado
através da IDE do Arduino
Cristal Clock 16Mhz- Responsável por
determinar com precisão a sincronia de tempo
das operações de um microcontrolador
Conector USB - Entrada do cabo USB para
programar na placa.
Conector DC de 7~12v - Conector de entrada
para alimentação da placa.
Reset - Botão utilizado para reiniciar o sistema
caso necessário.
Microcontrolador - CI principal responsável
por todo processamento do Arduino.
Led pino 13 - Led para teste da placa, utliza-
se o pino 13 como saída, através do código de
exemplo Blink encontrado na IDE do Arduino.
Conector ICSP - São os pinos responsáveis
para programar diretamente os
microcontroladores da placa usando o
protocolo serial SPI.
Led Power - O led que indentifica se placa
está energizada.
Leds de comunicação - Leds TX e RX
responsáveis pela indentificação no processo
de comunicação com o arduino.
Entradas e saídas digitais - Pinos que
podem ser configurados através do código
fonte como entradas ou saídas digitais.
Entradas analógicas ou saídas digitais
- Pinos que também podem ser configurados
através do código fonte como entradas ou
saídas digitais, e ainda possuem a capacidade
de serem analógicos, ou seja lerem valores de
tensão entre 0 e 5v.
Pinos de alimentação - São conectores de
alimentação para conexão de shields e
módulos na placa.

8
 No kit comercializado pela Multipeças Curitiba, a placa Arduino Unos R3 é da versão “SMD”;
conforme imagem abaixo que compara as duas versões.

ATENÇÃO:
Caso sua placa Arduíno não seja reconhecida pelo seu computador, é necessário a
instalação de um "driver" em seu sistema operacional, ou seja, um arquivo específico criado para
este processo de reconhecimento de hardware. Este driver varia de acordo com o modelo do CI
conversor da sua placa Arduíno e seu sistema operacional.

Veja mais informações nesta página, e os links para download do driver CH340.

9
 FAMÍLIA ARDUINO

Com o passar dos anos a linha Arduino vem crescendo mais e mais e trazendo soluções
para os mais diversos projetos. Conheça um pouco mais desta família:

10
 BAIXANDO E INSTALANDO A IDE ARDUINO

Antes de começar os projetos, vamos precisar de um programa chamado IDE (Integrated

Development Environment, ou Ambiente de Desenvolvimento Integrado). Com a IDE
Arduino podemos dar os primeiros passos, desenvolver programas e realizar a gravação dos
programas na placa.

Para fazer o download da IDE Arduino entre no site oficial do Arduino na seção Software -
> Downloads e escolha sua versão de sistema operacional(Windows, Linux, MacOS).

Se quiser fazer uma doação para o software Arduíno este é o momento. Se não, basta clicar
em Just Download.

11
Execute o arquivo instalador ‘.exe’ e siga as instruções de instalação.

Certifique-se de que todos os componentes na tela abaixo estejam selecionados.

12
Após a instalação, abra a IDE Arduíno pelo atalho criado na sua área de trabalho.

13
 ESTRUTURA DE UM PROGRAMA ARDUÍNO

Você não precisa ser um expert em programação para conseguir programar com Arduino,
mesmo assim, é bastante interessante que você procure entender o programa. No começo vai ser
mais complicado, algumas coisas podem não ficar tão claras, mas com experimentos e força de
vontade você será capaz de entender cada linha desse guia. Esse entendimento é essencial para
que você possa fazer seus próprios projetos no futuro.

Ao abrir a IDE Arduino, que instalamos anteriormente, você se depara com um programa em
branco, que não faz nada. A estrutura padrão de programa contém as funções setup() e loop().

setup() – É nessa parte do programa que você configura as opções iniciais do seu programa: os
valores iniciais de uma variável, se uma porta será utilizada como entrada ou saída, mensagens para
o usuário, etc. Essa função irá executar apenas uma vez quando o Arduino for ligado.

loop() – Diferente da função setup(), essa parte do programa repete uma estrutura de comandos de
forma contínua ou até que algum comando de “parar” seja enviado ao Arduino. Vamos ver
exatamente como isso funciona ao decorrer dos projetos.

Note que o conteúdo de cada função deve ir dentro das chaves “{ }”. O número de chaves que
abrem “{” devem ser o mesmo das que fecham “}”, senão o programa dá um erro e não é possível
passar para o Arduino. Se você tiver dificuldades em se entender com as chaves, a IDE do Arduino
te dá uma ajudinha: Basta clicar em uma chave que abre “{” que ele irá apontar a que fecha “}”. Se
você clica em uma chave que não mostra onde está o seu par, provavelmente ela está sobrando no
código.

14
 Você pode notar que existem coisas escritas após as barras duplas “//”, Isso é chamado de
comentário. Ele não altera seu funcionamento, mas serve para quem está programando explicar algo
para alguém que vai lê-lo. Uma das boas práticas de programação é documentar o seu código por
meio das linhas de comentário. Isso será útil não só para você, se precisar alterar o código depois
de algum tempo, como também para outras pessoas que utilizarão o seu programa.

15
 CARREGANDO UM PROGRAMA NO ARDUINO

Quando o código estiver pronto para ser carregado na placa, utilize o cabo usb para conectar
a placa Uno R3 no seu computador.

Com a placa conectada, entre no menu ferramentas, escolha o modelo da placa como
“Arduino/Genuino Uno” e a porta na qual a mesma está conectada, que no caso do sistema
Windows, será COM seguido de algum número, ex: COM3, COM4 ou COM5, etc. Caso não apareça
nenhuma porta, teste com outras entradas USB ou até mesmo em outro computador.

16
 Então clique no botão de checagem. Isso irá verificar se existe algum erro no código e gerar
o arquivo de programa necessário para carregar na placa.

Se estiver tudo OK, clique no botão carregar. Isso irá gravar o programa na placa.

Caso não apareça nenhum erro, você deverá ver o LED piscando em um intervalo de 1 segundo.

17
 PRIMEIRO PROJETO – PISCA PISCA

As portas do Arduíno podem ser digitais ou analógicas. Quando estávamos fazendo o LED
piscar, estávamos utilizando uma saída digital do Arduíno. Uma saída digital é composta por apenas
dois estados, ligado ou desligado. Um exemplo disso poderíamos ter ao jogar uma moeda que possui
apenas dois estados: ou cara ou coroa.
Por outro lado, uma saída analógica é composta por vários estados, podendo ser alto, pouco
alto, médio, pouco baixo, baixo. Por exemplo, um aparelho de som pode ter o volume muito alto, alto,
médio, pouco baixo ou baixo.

Usando as portas analógicas podemos também variar o brilho de um LED. No programa,

fazemos isso através da função analogWrite(), que manda um valor para uma saída analógica. Assim,
em vez de termos apenas dois estados, ligado/desligado, podemos ter vários estados intermediários,
variando assim o brilho do LED. Da mesma forma, é possível variar velocidade de motores, volume
de um som, temperatura em um chuveiro e etc. Mas isso é possível apenas nos pinos que estão
marcados com um til “~” indicando que o pino suporta a saída analógica. Para o nosso exemplo,
iremos utilizar o pino 11, que possui o indicador de saída analógica.
Neste primeiro projeto iremos fazer uma luz piscar. Parece um projeto simples demais, mas
isso exemplifica a utilização do Arduino para controle de dispositivos externos. Os conceitos
aprendidos neste exemplo servem para acionamento de outros dispositivos como ventilador,
lâmpadas, motores e etc.

18
 Fazer uma luz piscar é um projeto tão importante, que existe até uma competição internacional
para ver quem faz uma luz piscar de maneira mais impressionante, mostrando domínio de eletrônica
e programação. É o primeiro passo que se dá quando se começa a trabalhar com uma placa, porque
ele mostra que você é capaz de programá-la. Esse primeiro projeto será um pequeno grande passo
para que você aprenda eletrônica e programação e possa fazer projetos mais complexos.
Sabemos que o guia para este primeiro projeto está bastante longo, mas depois que você
entende como funciona, não irá precisar de tantas instruções para conseguir reproduzir um projeto.

- MATERIAL NECESSÁRIO

Em todos os projetos teremos uma seção que mostra os componentes que iremos utilizar. Se você
tiver alguma dúvida sobre qual é o componente, você pode voltar na lista de materiais:
1x LED Vermelho 5 mm
1x Resistor 220 ohm
1x Protoboard
2x Jumper macho-macho
1x Cabo USB
1x Placa Uno

Muitos nomes que você nunca viu na vida? Fique tranquilo que vamos explicar um pouco
como funciona cada componente novo que apareceu na lista. Claro que no primeiro projeto essa
explicação vai ser grande, mas conforme você for fazendo mais projetos, vai se familiarizando com
os componentes e essa lista de desconhecidos vai ficando cada vez menor.

- COMO FUNCIONA A PROTOBOARD?

A protoboard é um componente utilizado em todos os projetos do nosso kit e em quase todos

os projetos de eletrônica. É sobre ela que se faz a montagem dos circuitos eletrônicos, ação também
conhecida como prototipagem. Ela é cheia de furos, onde você pode encaixar os pinos dos
componentes ou mesmo um fio diretamente, e tem uma lógica de conexão entre os furos que, depois
que você entende, a montagem dos seus projetos fica bem intuitiva.

19
 Com a protoboard podemos experimentar a montagem de diversos tipos de combinações de
componentes eletrônicos e circuitos sem a necessidade de conectá-los permanentemente. Caso haja
a necessidade de trocar um componente de posição ou mesmo substituí-lo, isso pode ser feito de
maneira muito rápida e fácil.
Na protoboard existem dois blocos de colunas B e C. Cada coluna possui 5 furos e esses
estão interligados entre si como mostrado nas linhas cinzas. Uma coluna não possui conexão interna
com a coluna ao lado. Os blocos B e C não são interligados entre si, sendo separados por uma
cavidade central, e é que são colocadas a maior parte do circuito.

Já nos blocos A e D, nas extremidades superior e inferior da protoboard, temos as linhas em

vermelho e azul. Todos os furos de uma mesma linha estão interligados entre si, mas os furos da
linha vermelha não estão conectados aos furos da linha azul. Na linha vermelha existe um sinal de
positivo “+” e na azul um sinal de negativo ”-”. É nessas linhas que ligamos a energia do circuito que
vamos montar: nos projetos com Arduino, são os pinos 5 V e GND. Geralmente se coloca o 5 V no
vermelho e o GND no azul, mas isso não é uma regra e não vai mudar nada no circuito, é apenas
uma questão de organização.
Nos nossos projetos sugerimos uma montagem através de um desenho auxiliar. Mas se você
mantiver as mesmas conexões e respeitar a lógica da protoboard, pode montar o projeto em qualquer
lugar dela.

- O QUE É UM LED?

LED (do inglês, Light Emitting Diode) é um diodo emissor de luz, sendo basicamente é uma
lâmpada que consome pouca energia. Por seu baixo consumo, está se tornando cada vez mais
comum o seu uso em casas. Outra grande vantagem do LED é a facilidade de fabricação em diversas
cores e nesse kit você receberá LEDs das cores amarelo, verde e vermelho.
O LED, assim como alguns componentes, possui um lado positivo “+” e um lado negativo “-“,
essa característica também é conhecida como polaridade. Para esses componentes, se ligar de
modo invertido, ele não irá funcionar e pode até acabar danificando. A haste (perna) maior do LED é

20
o lado positivo e a menor é o lado negativo. Você pode ver também pelo lado mais achatado, que é
o lado negativo enquanto o lado arredondado é o positivo.

A montagem correta de um LED em uma protoboard é feita como mostrado na figura abaixo.
Os dois terminais do LED não podem ficar na mesma coluna da protoboard, lembrando que os furos
das colunas são conectados entre si na vertical. Esse mesmo princípio de montagem se aplica
também a outros componentes do kit.

21
- O QUE É UM RESISTOR?

O resistor é o componente elétrico mais comum que existe. Uma das aplicações de um
resistor, e a mais comum, é limitar o fluxo da corrente elétrica que passa em um circuito.
Os resistores têm diferentes valores de resistência, quanto mais alta a resistência, mais ele
irá limitar a corrente que passa por ele. O valor do resistor é fixo e é indicado pelas faixas de cores
pintada nele. No kit temos dois tipos: 220 ohm e 10K ohm.

Aviso! O kit pode conter resistores de coloração ou faixa de cores diferentes da ilustração acima,
mas não se preocupe, basta olhar o valor escrito na etiqueta do pacote de resistores. Caso
venham na cor amarela e quatro faixas, identifique-os de acordo com a ilustração abaixo:

Utilizando um resistor de valor 220 ohm, por exemplo, reduzimos a corrente do circuito para
trabalhar nos valores que o LED suporta. Sem o resistor, a corrente que passa pelo LED seria muito
grande e acabaria queimando ele.
Você pode ligar um resistor tranquilamente pois ele não tem lado positivo ou negativo, ou seja,
tanto faz o lado que é conectado.

22
- O QUE É UM JUMPER?

Jumper é o fio que liga os vários componentes de um circuito. Você pode ligá-los na
protoboard, na placa Arduino ou mesmo direto no componente. Para ajudar na organização do seu
circuito os jumpers vêm em diversas cores, mas as cores não alteram em nada o seu funcionamento.

Nos esquemas de montagens de circuitos eletrônicos, os jumpers são representados apenas

como traços coloridos, que ligam os componentes.

- COMO FUNCIONA UM CIRCUITO ELETRÔNICO?

Antes de montarmos o primeiro circuito é interessante aprender um pouco sobre o que é um

circuito e alguns conceitos básicos. Um circuito elétrico basicamente é um laço onde circula energia
elétrica, fazendo com que cada componente funcione. Veja abaixo um circuito básico de eletrônica
composto de uma fonte de energia, resistor e LED.

O lado positivo da fonte é chamado de VCC ou 5V e o lado negativo é chamado de GND.

Uma fonte pode ser uma bateria ou pilha que quando ligada faz com que o circuito funcione. Também
veremos que algumas portas do Arduíno podem fazer um papel de fonte, assim podemos ligar e
desligar o circuito utilizando programação.

23
 Nesse exemplo, o LED acende quando a fonte de energia é ligada e ao se desligar a fonte de
energia, o LED apagará. O resistor é colocado para reduzir a corrente que passa pelo circuito inteiro.

- MONTAGEM DO CIRCUITO

No caso do nosso projeto, a fonte de energia vem da porta 11 do Arduíno. Com a programação
correta, é possível ligar e desligar a energia do pino 11, fazendo o LED acender e apagar.
No esquema da montagem do circuito, as linhas coloridas são a representação gráfica dos
jumpers. Utilize-os para ligar os componentes entre si conforme a ilustração abaixo. Note que o pino
11 está conectado ao lado positivo do LED, enquanto o GND vai no pino negativo, passando antes
pelo resistor.

A representação de um circuito da montagem acima seria a seguinte:

24
 Não é necessário conectar os componentes exatamente nos mesmos furos como indicados
acima, basta apenas que os terminais de cada componente não estejam na mesma coluna. Também
não importa se o resistor está antes ou depois do LED, ele vai reduzir a corrente do laço estando
antes ou depois. Veja abaixo montagem alternativa do circuito acima, mas que funciona da mesma
maneira. Note que o pino GND do Arduíno ainda está conectado no negativo do LED e o pino 11
ainda está no positivo do LED.

Veja abaixo o circuito alternativo representando a montagem acima.

25
- PROGRAMANDO O PROJETO PISCA PISCA

Primeiramente vamos explicar um programa em partes e logo mais abaixo você verá um
programa completo.
A primeira coisa que fazemos no início do programa é colocar uma pequena observação sobre
o nome do programa, sua função e quem o criou:

1// Programa : Pisca pisca

2// Autor :

Comece uma linha com barras duplas “// ” e tudo o que vier depois nessa linha será tratado
como um comentário.
Após os comentários, vem a estrutura do setup(). É nela que definimos que o pino 11 do
Arduino será utilizado como saída, para servir como fonte de energia para o circuito.

1void setup()
2{
3 //Define a porta do led como saida
4 pinMode(11, OUTPUT);
5}

Por último, temos o loop(), que contém as instruções para acender e apagar o LED, e também
o intervalo entre essas ações:

1 void loop()
2 {
3 //Acende o led
4 digitalWrite(11, HIGH);
5
6 //Aguarda intervalo de tempo em milissegundos
7 delay(1000);
8
9 //Apaga o led
10 digitalWrite(11, LOW);
11
12 //Aguarda intervalo de tempo em milissegundos
13 delay(1000);
14 }

26
 A linha do código contendo digitalWrite(11, HIGH);, liga o pino 11, acendendo o led. O
comando delay(1000);, especifica o intervalo, em milésimos de segundos (milissegundos), no qual o
programa fica parado antes de avançar para a próxima linha. Quanto maior esse número, mais tempo
o programa vai esperar para passar para a próxima linha.
O comando digitalWrite(11, LOW);, apaga o LED, desligando o pino 11, e depois ocorre uma
nova parada (delay) no programa. Após essa espera, o processo é então reiniciado, voltando para o
início do loop().
Você reparou que todo comando termina com um ponto e vírgula “;“? Ele é muito importante
na programação porque define que o comando acabou ali. Se está faltando um “;” o programa não
irá funcionar de jeito nenhum!
Abaixo você encontra o programa completo que pode ser copiado e colado direto na IDE
Arduíno:

1 // Primeiro Projeto: Pisca Pisca pisca

2 // Autor :
3
4 void setup()
5 {
6 //Define a porta do led como saida
7 pinMode(11, OUTPUT);
8 }
9
10 void loop()
11 {
12 //Acende o led
13 digitalWrite(11, HIGH);
14
15 //Aguarda intervalo de tempo em milissegundos
16 delay(1000);
17
18 //Apaga o led
19 digitalWrite(11, LOW);
20
21 //Aguarda intervalo de tempo em milissegundos
22 delay(1000);
23 }

Mude o intervalo de tempo que o LED pisca mudando o valor na programação na

linha delay(1000); por exemplo: delay(250). Esta alteração fará com que o LED pisque mais rápido!
Experimente outros valores.

27
- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Na hora da checagem, apareceu alguma mensagem em vermelho? Verifique o código e caso

não encontre o problema, copie e cole novamente o código na IDE Arduíno e tente mais uma
vez;
• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduíno;
• Verifique se o LED não está conectado invertido ou seja, terminal negativo no pino 11 e
positivo no pino GND;
• Verifique se o código carregou na placa através da IDE Arduíno.

28
 SEGUNDO PROJETO – S.O.S. LUMINOSO

Você já deve ter visto nos filmes quando as pessoas enviam pedido de socorro SOS em
código morse. Neste projeto iremos piscar um LED no padrão SOS. A letra S são 3 piscadas curtas
indicando o ponto do código morse e a letra O são 3 piscadas um pouco mais longas indicando o
traço do código morse.

Este projeto mostra que, através da programação, podemos piscar o LED de diferentes maneiras e
intervalos de tempo.

- MATERIAL NECESSÁRIO

1x LED Vermelho 5mm

1x Resistor 220 ohm
1x Protoboard
2x Jumper macho-macho
1x Cabo USB
1x Placa Uno

29
- MONTAGEM DO CIRCUITO

Nesse projeto vamos utilizar o mesmo circuito do Projeto Pisca pisca.

- PROGRAMANDO O PROJETO S.O.S COM LED

O programa, como feito com o Projeto Pisca pisca, acende e apaga a luz conforme um padrão.
Como algumas coisas se repetem, foi acrescentada uma estrutura no código para repetição.
A ideia não é entender exatamente como as estruturas de repetição funcionam, mas sim que
elas existem. Quando precisar utilizar alguma dessas estruturas em um projeto, você pode procurar
como é feito, ou mesmo alterar os valores nesse código.

1 // Segundo Projeto - Sinal de SOS com LED

2 int pinoLed = 11;
3
4 void setup() {
5 pinMode(pinoLed, OUTPUT);
6 }
7
8 void loop() {
9
10 // S(...) tres pontos
11 for(int x=0;x<3;x++) // Repete tudo dentro das chaves tres vezes
12 {

30
13 digitalWrite(pinoLed,HIGH); // Acende o LED
14 delay(150); // Aguarda
15 digitalWrite(pinoLed,LOW); // Desliga o LED
16 delay(100); // Aguarda novamente
17 }
18
19 delay(200);
20
21 // O(---) tres linhas
22 for(int x=0;x<3;x++)
23 {
24 digitalWrite(pinoLed,HIGH);
25 delay(450);
26 digitalWrite(pinoLed,LOW);
27 delay(150);
28 }
29
30 delay(200);
31
32 //S(...) tres pontos
33 for(int x=0;x<3;x++)
34 {
35 digitalWrite(pinoLed,HIGH);
36 delay(150);
37 digitalWrite(pinoLed,LOW);
38 delay(100);
39 }
40
41 delay(5000);
42 }

- POSSÍVEIS ERROS

Caso o projeto não funcione verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduino;
• Verifique se o LED não está conectado invertido ou seja, terminal negativo no pino 11 e
positivo no pino GND;
• Verifique se o código carregou na placa através da IDE Arduino.

31
 TERCEIRO PROJETO – BRILHO OSCILANTE

Nos projetos anteriores vimos como ligar e desligar o nosso LED. Mas e se quiséssemos
variar o brilho dessa luz? Com diversos componentes às vezes queremos variar a sua intensidade, e
não apenas ligar ou desligar. Um motor, por exemplo, podemos querer variar a sua velocidade. Para
isso usaremos uma função diferente do Arduíno, a sua saída analógica.

- MATERIAL NECESSÁRIO

1x LED Vermelho 5mm

1x Resistor 220 ohm
1x Protoboard
2x Jumper macho-macho
1x Cabo USB
1x Placa Uno

- MONTAGEM DO CIRCUITO

Neste projeto continuaremos com o mesmo circuito dos projetos anteriores

32
- PROGRAMANDO O PROJETO BRILHO OSCILANTE

1 // Terceiro Projeto - Brilho Oscilante

2
3 // configura a saída 11 como pino do LED
4 int pinoLed = 11;
5
6 void setup() {
7 // configura pino do LED como saída
8 pinMode(pinoLed,OUTPUT);
9 }
10
11 void loop(){
12 acendeBrilho(5);
13 apagaBrilho(5);
14 }
15
16 void acendeBrilho(int increamento){
17 // muda o brilho pelo loop for
18 for (byte value = 0 ; value < 255; value+=increamento){
19 // controla o brilho no pino do LED
20 analogWrite(pinoLed, value);

33
21 delay(30);
22 }
23 }
24
25 void apagaBrilho(int decreamento){
26 // muda o brilho pelo loop for
27 for (byte value = 255; value >0; value-=decreamento){
28 // controla o brilho no pino do LED
29 analogWrite(pinoLed, value);
30 delay(30);
31 }
32 }

- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduino;
• Verifique se o LED não está conectado invertido, ou seja, terminal negativo no pino 11 e
positivo no pino GND;
• Verifique se o código carregou na placa através da IDE Arduino.

34
 QUARTO PROJETO - SEMÁFORO

Já está sabendo tudo de LEDs e como ligá-los? Então vamos montar esse projeto maior
para juntar várias coisas que aprendemos até agora.
Este projeto irá simular um semáforo de carros e pedestres. Serão três LEDs para os carros
e dois para os pedestres. A sequência inicia com o LED verde dos carros aceso e vermelho para
pedestres. O semáforo dos carros então passa para cor amarela indo para cor vermelha,
juntamente com o LED verde de pedestres. O LED vermelho dos pedestres então pisca e a
sequência volta ao início.

- MATERIAL NECESSÁRIO

2x LED Vermelho 5mm

2x LED Verde 5mm
1x LED Amarelo 5mm
5x Resistor 220 ohm
1x Protoboard
11x Jumper macho-macho
1x Cabo USB
1x Placa Uno

35
- MONTAGEM DO CIRCUITO

O grande desafio deste projeto está em montar os LEDs corretamente, pois o circuito
consiste de mais LEDs, mais resistores e mais jumpers. Agora faremos uso de uma das linhas
inferiores da protoboard, conectando o pino GND (negativo) do Arduíno na linha azul da protoboard.

A maioria das pessoas, mesmo makers experientes, tem que voltar para esta parte do
projeto e refazer, não se preocupe. Se você conseguir fazer a montagem funcionar na primeira
tentativa, parabéns!

- PROGRAMANDO O PROJETO SEMÁFORO

Esse código, apesar de parecer extenso, é simples. Não tem nada que ainda não foi visto
neste guia. Procure entender o código e ver o que irá acontecer a partir dele.
Como todo código, começamos definindo as variáveis, os pinos utilizados e, por fim,
o loop() que fica repetindo continuamente.
Se estiver com problemas para entender, você pode ler os comentários dentro do programa
e/ou voltar nos projetos 1 e 2.

1 // Quarto Projeto - Semáforo

2
3 int pedVerde = 9; // Define os pinos que serao utilizados
4 int pedVermelho = 8;
5 int carroVerde = 12;
6 int carroAmarelo = 11;
7 int carroVermelho = 10;
8

36
9 void setup() // Define os pinos como saidas
10 {
11 pinMode(pedVerde, OUTPUT);
12 pinMode(pedVermelho, OUTPUT);
13 pinMode(carroVerde, OUTPUT);
14 pinMode(carroAmarelo, OUTPUT);
15 pinMode(carroVermelho, OUTPUT);
16
17 digitalWrite(carroVerde, HIGH); // Posição inicial. Somente o verde dos carros e o vermelho dos pedestres
18 digitalWrite(carroAmarelo, LOW);
19 digitalWrite(carroVermelho, LOW);
20 digitalWrite(pedVerde, LOW);
21 digitalWrite(pedVermelho, HIGH);
22 }
23
24 void loop()
25 {
26 digitalWrite(carroVerde, HIGH); // Acende o verde dos carros e o vermelho dos pedestres
27 digitalWrite(pedVermelho, HIGH);
28 delay(5000); // Aguarda 5 segundos
29 digitalWrite(carroVerde, LOW);
30 digitalWrite(carroAmarelo, HIGH); // apaga o verde dos carros e acende o amarelo
31 delay(3000); // aguarda mais 3 segundos
32 digitalWrite(carroAmarelo, LOW); // apaga o amarelo dos carros e acende o vermelho
33 digitalWrite(carroVermelho, HIGH);
34 digitalWrite(pedVermelho, LOW); // apaga o vermelho dos pedestres e acende o verde
35 digitalWrite(pedVerde, HIGH);
36 delay(5000); // aguarda mais 5 segundos
37 digitalWrite(pedVerde, LOW);
38 for(int x = 0; x<5; x++) // Pisca o vermelho dos pedestres
39 {
40 digitalWrite(pedVermelho, HIGH);
41 delay(250);
42 digitalWrite(pedVermelho, LOW);
43 delay(250);
44 }
45 digitalWrite(carroVermelho, LOW);
46 }

37
 Conseguiu pegar a lógica do programa? Você pode alterá-la conforme bem entender e fazer
a sua própria lógica de semáforo!

- POSSÍVEIS ERROS

Caso o projeto não funcione verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduino;
• Verifique se o LED não está conectado invertido;
• Verifique se o código carregou na placa através da IDE Arduino.

38
 QUINTO PROJETO – INTERRUPTOR DE LUZ

Neste projeto, veremos que também é possível acionar dispositivos através de interação
humana. Agora alguns pinos serão porta de entrada, e não só saída como eram os projetos até
aqui.

O funcionamento deste projeto mostra como acionar um LED pressionando uma chave
push-button (botão). Isso exemplifica que o Arduíno pode receber ou ler informações externas e
tomar ações a partir deles.

Uma chave push-button funciona como um contato que abre e fecha, sendo assim, uma
chave possui dois valores, 0 ou 1, aberto ou fechado. Conectando uma chave a uma porta do
Arduino podemos ler o valor 0 ou 1 da chave e assim tomar uma ação, que no caso do nosso
exemplo será acionar o LED. Por só ter dois valores possíveis, utilizaremos uma das portas digitais
da placa.

39
 O botão, quando pressionado, faz contato entre um lado e outro dele. Quando esse contato
é fechado, essa corrente elétrica “entra” na placa e ela percebe que o botão foi pressionado. Ao
escrevermos o programa, decidiremos o que fazer com essa informação.

- MATERIAL NECESSÁRIO

1x LED Vermelho 5mm

1x Resistor 220 ohm
1x Chave Táctil Push-button
1x Protoboard 400 pontos
5x Jumper Macho-macho
1x Cabo USB
1x Placa Uno

- MONTAGEM DO CIRCUITO

A chave táctil push button deve ser montada com dois terminais acima da cavidade central
da protoboard e os outros dois abaixo. Um terminal da chave vai no pino 7 e outro no GND. No
caso deste projeto o pino do LED é uma saída digital e o pino da chave é uma entrada digital.

40
- PROGRAMANDO O PROJETO INTERRUPTOR DE LUZ

Para ler o valor digital de um botão, primeiro temos que configurar o pino como entrada
utilizando pinMode(botao, INPUT_PULLUP); e então fazer a leitura
com digitalRead(botao); Sendo o valor da leitura 0 ou 1 (LOW ou HIGH), controlamos o LED de
acordo. Veja o programa completo abaixo:

1// Quinto Projeto - Interruptor de luz

2
3int botao = 7;
4int led = 13;
5bool estadoLed = 0;
6
7void setup()
8{
9 pinMode(botao, INPUT_PULLUP); // define o pino do botao como entrada "INPUT"
10 pinMode(led, OUTPUT);
11}
12
13void loop()
14{
15 if(digitalRead(botao) == LOW) // Se o botão for pressionado
16 {
17 estadoLed = !estadoLed; // troca o estado do LED

41
18 digitalWrite(led, estadoLed);
19 while(digitalRead(botao) == LOW);
20 delay(100);
21 }
22}

- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduíno;
• Verifique se o LED não está conectado invertido;
• Verifique se os pinos do botão estão bem inseridos na protoboard;
• Verifique se o código carregou na placa através da IDE Arduíno.

42
 SEXTO PROJETO – LUZES COLORIDAS

Alguns LEDs são capazes de mudar a sua cor, chamamos eles de LED RGB. Ele tem o
mesmo funcionamento básico de um LED comum porém possui três cores no mesmo componente,
como se fossem três LEDs juntos: Red(R), Green(G) e Blue(B). Assim podemos trocar as cores via
programação e até mesmo fazer misturas.

Como mostrado na figura abaixo, o LED RGB possui quatro pernas, sendo a perna maior o
pino positivo comum para todos os LEDs internos.

O Projeto 6 consiste em alternar entre as 3 cores do LED RGB através do Arduíno em um

intervalo de 1 segundo.

43
- MATERIAL NECESSÁRIO

1x LED RGB 5mm

3x Resistor 220 ohm
5x Jumper Macho-macho
1x Cabo USB
1x Placa Uno

- MONTAGEM DO CIRCUITO
A montagem deste circuito é feita como se fossem três LEDs colocados no mesmo
projeto. Adicione um resistor para cada perna de cor do LED RGB e conecte o pino 5 V do Arduíno à
perna positiva do LED RGB. Cada pino de cor do LED é conectado a uma porta digital do Arduíno.

44
Importante! Note que o fio vermelho 5 V deve ser conectado à perna mais comprida do LED.

- PROGAMANDO O PROJETO LUZES COLORIDAS

O programa consiste em alternar cada uma das cores do LED em um intervalo de 1 segundo.

1 // Sexto Projeto - Luzes Coloridas

2
3 int led_R = 7; // pino LED Vermelho (R)
4 int led_G = 6; // pino LED Verde (G)
5 int led_B = 5; // Pino LED Azul (B)
6
7 void setup()
8 {
9 pinMode(led_R, OUTPUT); // Definimos os pinos como saida
10 pinMode(led_G, OUTPUT);
11 pinMode(led_B, OUTPUT);
12 apagaLed();
13 }
14
15 void loop()
16 {
17 acendeVermelho(); // aqui fizemos uma pequena funcao que acende uma cor e apaga as outras
18 delay(1000);
19 acendeVerde();
20 delay(1000);
21 acendeAzul();
22 delay(1000);
23 apagaLed();
24 delay(1000);
25
26 }
27
28 void acendeVermelho()
29 {
30 digitalWrite(led_R, LOW);
31 digitalWrite(led_G, HIGH);
32 digitalWrite(led_B, HIGH);
33 }
34

45
35 void acendeVerde()
36 {
37 digitalWrite(led_R, HIGH);
38 digitalWrite(led_G, LOW);
39 digitalWrite(led_B, HIGH);
40 }
41
42 void acendeAzul()
43 {
44 digitalWrite(led_R, HIGH);
45 digitalWrite(led_G, HIGH);
46 digitalWrite(led_B, LOW);
47 }
48
49 void apagaLed()
50 {
51 digitalWrite(led_R, HIGH);
52 digitalWrite(led_G, HIGH);
53 digitalWrite(led_B, HIGH);
54 }

- POSSÍVEIS ERROS

Caso o projeto não funcione verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduíno;
• Verifique se o terminal positivo do LED RGB está na posição correta ligado ao 5 V do Arduíno;
• Verifique se o código carregou na placa através da IDE Arduíno.

46
 SÉTIMO PROJETO – TROCANDO A COR DAS LUZES

No projeto anterior, fizemos um LED RGB piscar sem parar com cores diferentes. Neste
projeto você que irá comandar como o LED irá variar a sua cor. Para dar os comandos para a placa
Arduíno, iremos utilizar um potenciômetro.

No Projeto 1, falamos um pouco sobre o que é um resistor e nesse projeto iremos utilizar um
resistor variável chamado potenciômetro. Diferente de um botão que é digital e tem um valor de 0 ou
1, o potenciômetro varia o seu valor conforme a rotação de sua haste e, por isso, deve ser conectado
em uma porta analógica do Arduíno.
O potenciômetro é bastante usado em controles de volume, intensidade de lâmpadas e etc.
Veja na figura abaixo o seu funcionamento interno.

O projeto 7 consiste em controlar as cores do LED RGB ao rotacionar o potenciômetro.

47
- MATERIAL NECESSÁRIO

1x LED RGB 5mm

1x Potenciômetro 10K ohm
3x Resistor 220 ohm
1x Protoboard
9x Jumper Macho-macho
1x Cabo USB
1x Placa Uno

- MONTAGEM DO CIRCUITO

A montagem do LED RGB é a mesma do projeto anterior. Adicione o potenciômetro ligando

um pino em 5 V, outro em GND e seu pino central em uma porta analógica do Arduíno. Não se
preocupe com o lado, assim como um resistor comum, o potenciômetro não tem lado positivo ou
negativo, ou seja, tanto faz o lado que é conectado ao circuito. O único cuidado que se deve ter ao
colocar o potenciômetro na protoboard é o encaixe, que tem que apertar um pouco.

48
- PROGRAMANDO O PROJETO TROCANDO A COR DAS LUZES

Para ler o valor de um potenciômetro ou qualquer componente que tenha um sinal variável
fazemos uso da função analogRead() que transforma a rotação do potenciômetro em valores de 0 a
1023.
O programa consiste em alternar as cores do LED RGB conforme o potenciômetro é
rotacionado, lendo o valor do mesmo através da função analogRead().

1 // Setimo Projeto - Trocanndo a cor das luzes

2
3 int led_R = 7; // pino LED Vermelho (R)
4 int led_G = 6; // pino LED Verde (G)
5 int led_B = 5; // Pino LED Azul (B)
6 int pot = A0;
7
8 int valorPot;
9
10 void setup()
11 {
12 pinMode(led_R, OUTPUT);
13 pinMode(led_G, OUTPUT);
14 pinMode(led_B, OUTPUT);

49
15 apagaLed();
16 }
17
18 void loop()
19 {
20 valorPot = analogRead(pot); // lê o valor do potenciômetro (de 0 a 1023)
21 if(valorPot >= 0 && valorPot <= 256) // menor que 256 apaga o LED
22 {
23 apagaLed();
24 }
25 if(valorPot > 256 && valorPot <= 512) // entre 256 e 512, acende vermelho
26 {
27 acendeVermelho();
28 }
29 if(valorPot > 512 && valorPot <= 768) // entre 512 e 768, acende verde
30 {
31 acendeVerde();
32 }
33 if(valorPot > 768 && valorPot <= 1023) // entre 768 e 1023, acende azul
34 {
35 acendeAzul();
36 }
37 }
38
39 void acendeVermelho()
40 {
41 digitalWrite(led_R, LOW);
42 digitalWrite(led_G, HIGH);
43 digitalWrite(led_B, HIGH);
44 }
45
46 void acendeVerde()
47 {
48 digitalWrite(led_R, HIGH);
49 digitalWrite(led_G, LOW);
50 digitalWrite(led_B, HIGH);
51 }
52
53 void acendeAzul()
54 {
55 digitalWrite(led_R, HIGH);

50
56 digitalWrite(led_G, HIGH);
57 digitalWrite(led_B, LOW);
58 }
59
60 void apagaLed()
61 {
62 digitalWrite(led_R, HIGH);
63 digitalWrite(led_G, HIGH);
64 digitalWrite(led_B, HIGH);
65 }

- POSSÍVEIS ERROS

Caso o projeto não funcione verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduino;
• Verifique se o terminal positivo do LED RGB está na posição correta, ligado ao 5 V do Arduino;
• Verifique se os pinos do potenciômetro estão totalmente inseridos nos furos da protoboard;
• Verifique se o código carregou na placa através da IDE Arduino.

51
 OITAVO PROJETO – ACIONANDO UM MOTOR

Existem diversos tipos de motor que podem ser utilizados facilmente com o Arduino. Entre
os mais fáceis de se utilizar está o servo motor, sendo bastante utilizado em aeromodelismo e
outros projetos que precisam de pouco movimento.
O servo motor é, basicamente, um motor onde é possível controlar sua posição. O servo
consegue fazer um movimento de rotação de até meia volta, não fica girando como alguns
motores. Porém, existem outros modelos de servo motor que conseguem dar voltas completas,
sendo cada modelo indicado para um tipo de projeto diferente.

Você lembra do Projeto 3, onde controlamos o brilho de um LED? O princípio é basicamente

o mesmo. O Projeto 8 consiste em movimentar um servo ao pressionar um botão. Para isso vamos
precisar de uma entrada digital para o botão e uma saída analógica para o servo motor. Conforme
variamos a saída analógica do servo, variamos a sua posição.

52
- MATERIAL NECESSÁRIO

1x Servo 9g
1x Chave push-button
7x Jumper Macho-macho
1x Cabo USB
1x Placa Uno

- MONTAGEM DO CIRCUITO

O servo possui três fios para sua utilização e na extremidade desses fios um conector de 3
pinos fêmea. O fio marrom do servo deve ser conectado ao GND, o fio vermelho ao 5 V e o fio
laranja ao pino 9 do Arduino. Na ilustração abaixo o fio preto corresponde ao marrom, o fio
vermelho ao vermelho e o fio amarelo ao fio laranja.

Para conectar o servo basta utilizar 3 jumpers macho-macho e ligar o conector do servo
com a protoboard. Também acompanha algumas hastes e parafusos. Não é necessário parafusar
as hastes ao servo, apenas um encaixe já basta. Você pode escolher uma das hastes para
visualizar melhor o movimento do servo.

53
- PROGRAMANDO O PROJETO ACIONANDO UM MOTOR

No oitavo projeto, o programa deve fazer o seguinte: ao apertar o botão, o servo gira até
meia volta (180 graus) e retorna, ficando parado até pressionar o botão novamente.

1 // Oitavo Projeto - Acionando um Motor

2
3 #include <Servo.h>
4
5 Servo meuServo;
6 int botao = 7;
7
8 void setup()
9 {
10 pinMode(botao, INPUT_PULLUP); // define o botão como saidas
11 }
12
13 void loop()
14 {
15 [Link](9);
16 if(digitalRead(botao) == LOW)
17 {
18 for(int angulo=0; angulo<=180; angulo++) // Aumenta o angulo do servo ate chegar em 180 graus
19 {
20 [Link](angulo);
21 delay(10);

54
22 }
23 for(int angulo=180; angulo>=0; angulo--)// Diminui o angulo do servo
24 {
25 [Link](angulo);
26 delay(10);
27 }
28 }
29 [Link]();
30 }

- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduino;
• Verifique se as conexões do servo estão corretas, fio marrom no GND, fio vermelho no 5 V
e laranja no pino 9;
• Verifique se os pinos do botão estão bem inseridos na protoboard;
• Verifique se o código carregou na placa através da IDE Arduino.

55
 NONO PROJETO – CONTROLANDO UM MOTOR

Já vimos no projeto 7 como funciona um potenciômetro e no projeto 8 como funciona um

servo motor. No projeto 9, veremos como utilizar esses dois componentes em conjunto controlando
o servo através da rotação do potenciômetro.

É interessante observar como os dois componentes utilizam portas analógicas. Com isso
podemos ler diversos valores no potenciômetro e mandar esses valores diversos para o motor. Não
é apenas um comando de ligado e desligado, como no Projeto 5 Interruptor de luz.

- MATERIAL NECESSÁRIO

1x Servo 9g
1x Potenciômetro 10K ohm
8x Jumper macho-macho
1x Cabo USB
1x Placa Arduino Uno

- MONTAGEM DO CIRCUITO

Como já visto no projeto 8, o servo possui três fios para sua utilização e na extremidade
desses fios um conector de 3 pinos fêmea. O fio marrom do servo deve ser conectado ao GND, o fio
vermelho ao 5 V e o fio laranja ao pino 9 do Arduíno.
Para conectar o servo basta utilizar 3 jumpers macho-macho. Também acompanha algumas
hastes e parafusos. Não é necessário parafusar as hastes ao servo, apenas um encaixe já basta.
Adicione também na montagem o potenciômetro, como visto no Projeto 7.

56
- PROGRAMANDO O PROJETO CONTROLANDO O MOTOR

O programa consiste em ler o valor de rotação do potenciômetro e controlar a rotação do

servo de acordo.

1 // Nono Projeto - Controlando um Motor

2
3 #include <Servo.h>
4
5 Servo meuServo;
6
7 int pinoPot = A0;
8 int valorPot;
9
10 void setup()
11 {
12 [Link](9);
13 }
14
15 void loop()
16 {
17 valorPot = analogRead(pinoPot);
18 valorPot = map(valorPot, 0, 1023, 0, 180); // mapeia os valores do potenciometro para os valores

57
19 [Link](valorPot); // manda o valor para o servo
20 delay(15);
21 }

- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduino;
• Verifique se as conexões do servo estão corretas, fio marrom no GND, fio vermelho no 5V e
laranja no pino 9;
• Verifique se os pinos do potenciômetro estão bem inseridos na protoboard;
• Verifique se o código carregou na placa através da IDE Arduino.

58
 DÉCIMO PROJETO – SENSOR DE LUZ AMBIENTE

Neste projeto iremos mostrar que é possível identificar a quantidade de luz presente em um
ambiente utilizando o Arduíno e o sensor de luminosidade LDR (Light Dependent Resistor). O LDR
é bastante usado nos postes de luz na cidade, fazendo que quando anoiteça as luzes da cidade
acendam. Ele também é usado em lâmpadas de jardim que acendem ao anoitecer. Veja neste
projeto como utilizar o sensor de luz LDR com Arduíno.

Assim como um potenciômetro varia sua resistência conforme a rotação, o LDR é um

resistor que varia sua resistência conforme a intensidade de luz no ambiente. Com isso
conseguimos medir a quantidade de luz presente em um ambiente.

Da mesma forma que o potenciômetro é ligado em uma entrada analógica do Arduino,

também é possível utilizar uma porta analógica para ler o valor de um LDR. Para o LED, iremos
trabalhar apenas com uma porta digital.
O projeto 10 consiste em ligar ou desligar o LED de acordo com a intensidade de luz
presente no ambiente. Pouca luz acende o LED, bastante luz apaga o LED. Você pode variar a luz
do ambiente acendendo ou apagando as luzes ou colocando a mão em cima do sensor LDR como
mostrado abaixo.

59
- MATERAL NECESSÁRIO

1x LED Vermelho 5 mm
1x Resistor 220 ohm
1x Resistor 10K ohm
1x Sensor de luminosidade LDR
7x Jumper Macho-macho
1x Cabo USB
1x Placa Uno

- MONTAGEM DO CIRCUITO

Na montagem deste projeto, atente-se a montagem do LED, pois, como já mostramos no

projeto 1, ele tem lado positivo e negativo. Já o sensor de luminosidade LDR não tem lado, ou seja
apenas insira os seus pinos na protoboard e faça a ligação conforme indicado abaixo. Note que o
LDR usa um resistor de 10K ohm e o LED um resistor de 100 ohm.

60
- PROGRAMANDO O PROJETO SENSOR DE LUZ

1 // Decimo Projeto - Sensor de luz ambiente

2
3 int pinoLed = 13;
4 int pinoSensorLuz = A0;
5 int valorLuz = 0;
6
7 void setup()
8 {
9 pinMode(pinoLed,OUTPUT);
10 }
11
12 void loop()
13 {
14 valorLuz = analogRead(pinoSensorLuz);
15 if(valorLuz<750)
16 {
17 digitalWrite(pinoLed,HIGH);
18 }
19 else
20 {
21 digitalWrite(pinoLed,LOW);
22 }

61
23 delay(10);
24 }

- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduino;
• Verifique se o valor de resistores está correto como indicado na montagem do projeto;
• Verifique se o código carregou na placa através da IDE Arduino.

62
 DÉCIMO PRIMEIRO PROJETO – DÓ RÉ MI

Bora fazer música com o Arduíno?

Na música, cada nota musical possui uma frequência específica dada em hertz (Hz). Olhando
as teclas de um piano é possível ver a frequência de cada uma das notas de uma escala de Dó por
exemplo. No projeto 11 iremos mostrar como é possível reproduzir notas musicais utilizando um
buzzer com Arduíno.

O buzzer é um pequeno alto falante capaz de gerar tons em frequências determinadas, sendo
possível, então, tocar pequenas músicas ou alarmes. Ele é bastante encontrado em brinquedos ou
relógios digitais com alarme. No Arduíno podemos utilizar a função chamada tone(); que leva dois
parâmetros: o pino em que o buzzer está conectado e a frequência do tom. O projeto 11 consiste em
tocar a escala de dó com Arduíno e buzzer.

- MATERIAL NECESSÁRIO

1x Buzzer
2x Jumper Macho-macho
1x Protoboard
1x Cabo USB
1x Placa Uno

63
- MONTAGEM DO CIRCUITO

- PROGRAMANDO O PROJETO DÓ RÉ MI

1 // Decimo PrimeiroProjeto - Dó Ré Mi
2
3 #define DO 262
4 #define RE 294
5 #define MI 330
6 #define FA 349
7 #define SOL 392
8 #define LA 440
9 #define SI 494
10 #define DO_2 523
11
12 int pinoBuzzer = 6;
13
14 int melodia[] = {
15 DO, RE, MI, FA, SOL, LA, SI, DO_2
16 };
17
18 void setup() {

64
19 // configura pino do buzzer como saída
20 pinMode(pinoBuzzer,OUTPUT);
21 }
22
23 void loop() {
24 for(int i=0; i<8; i++)
25 {
26 tone(pinoBuzzer, melodia[i]);
27 delay(500);
28 }
29 }

- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduíno;
• Verifique se o código carregou na placa através da IDE Arduíno.

65
 DÉCIMO SEGUNDO PROJETO – ALARME A LASER

Para este projeto, vamos combinar o Projeto 10 e o Projeto 11 para criar um detector de
presença a laser, igual àqueles que vemos em filmes de espionagem, mas com um laser somente.
Claro que aprendendo o funcionamento deste projeto você pode juntar mais lasers e fazer um
sensor mais parecido com os encontrados em filmes.

O diodo laser é um LED que possui uma lente especial que gera um feixe de luz de longo
alcance e, normalmente, em formato de ponto. Nesse projeto também iremos utilizar o sensor de
luz LDR para detectar o laser e o buzzer para realizar sinais sonoros.

No projeto 12 iremos fazer um protótipo de alarme por laser. O laser deve ser apontado para
o LDR, para que o sensor detecte bastante luz, e quando algo cortar o feixe de luz, o buzzer irá
soar como um alarme. Veja como o projeto irá funcionar.

66
- MATERIAL NECESSÁRIO

1x Diodo Laser
1x Resistor 10K ohm
1x LDR
1x Buzzer
9x Jumper Macho-macho
1x Cabo USB
1x Placa Uno

- MONTAGEM DO CIRCUITO

Na montagem abaixo note que o laser está com os fios conectados diretamente na
protoboard e apontando para o LDR. Caso o laser não acenda, verifique se fios foram colocados
até o fundo dos furos da protoboard. Atenção! Não aponte o laser diretamente no seu olho ou
de outra pessoa.

Veja como deve ser feita a montagem do laser.

67
- PROGRAMANDO O PROJETO ALARME A LASER

No programa abaixo, quando o laser não estiver apontado para o LDR, o buzzer irá soar.
Sendo assim, aponte o laser para o LDR e corte o
feixe de luz com um objeto para que o alarme acione.

1 // Decimo Segundo Projeto - Alarme com sensor a laser

2
3 int pinoSensorLuz = A0;
4 int pinoBuzzer = 6;
5 int valorLuz = 0;
6
7 void setup()
8 {
9 // configura pino do buzzer como saída
10 pinMode(pinoBuzzer,OUTPUT);
11 }
12
13 void loop()
14 {
15 valorLuz = analogRead(pinoSensorLuz);
16 if(valorLuz<950)
17 {
18 tone(pinoBuzzer, 440);
19 }

68
20 else
21 {
22 noTone(pinoBuzzer);
23 }
24 delay(10);
25 }

- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduíno;
• Verifique se os valores de resistores estão corretos como indicado na montagem;
• Verifique se o laser está com os fios bem inseridos nos furos da protoboard;
• Verifique se o código carregou na placa através da IDE Arduíno.

69
 DÉCIMO TERCEIRO PROJETO – ALARME DE MOVIMENTO

No Projeto 13, faremos um alarme que apita quando detecta movimento. Para o apito
utilizaremos o já conhecido buzzer, e para detectar o movimento iremos utilizar o sensor de vibração
e movimento tilt, que funciona como um botão que é acionado ao ser inclinado ou agitado. Ao ser
agitado, ele envia a informação de inclinação que pode ser lida pelo Arduíno e, uma ação pode ser
tomada.

A ilustração abaixo é uma representação gráfica da pequena cápsula azul presente no sensor
de vibração tilt e não necessariamente representa exatamente a construção física do componente.

O sensor de vibração tilt tem um formato de módulo que contém a cápsula azul e também um
pequeno potenciômetro para ajuste da sensibilidade.

70
- MATERIAL NECESSÁRIO

1x Sensor de vibração tilt

1x Chave de ajuste para sensor de vibração
1x Buzzer
7x Jumper Macho-macho
1x Cabo USB
1x Placa Uno

- MONTAGEM DO CIRCUITO

Monte o projeto como abaixo encaixando os pinos do módulo de vibração tilt na protoboard.
Para que o projeto funcione adequadamente é necessário ajustar o sensor de vibração tilt através do
pequeno potenciômetro azul, girando-o totalmente para direita como indicado pela seta vermelha.

Para girar o potenciômetro utilize uma chave de fenda pequena (não acompanha o kit).

71
- PROGRAMANDO O PROJETO ALARME DE MOVIMENTO

1 // Decimo terceiro Projeto - Alarme de movimento

2
3 int pinoTilt = 7;
4 int pinoBuzzer = 6;
5
6 void setup()
7 {
8 pinMode(pinoTilt, INPUT);
9 }
10
11 void loop()
12 {
13 if(digitalRead(pinoTilt) == HIGH)
14 {
15 tone(pinoBuzzer, 440);
16 delay(1000);
17 }
18 else
19 {
20 noTone(pinoBuzzer);
21 }
22 }

- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduino;
• Verifique se o potenciômetro do sensor de vibração foi ajustado conforme instrução da
montagem;
• Verifique se o código carregou na placa através da IDE Arduino

72
 DÉCIMO QUARTO PROJETO – CONTADOR DIGITAL

O contador digital é um display de um dígito que vai aumentando conforme o tempo. Como
ele é um contador de um dígito apenas, começa em 0 e vai até 9. O projeto 9 parece um projeto um
pouco simples, mas que ensina o funcionamento de um display bastante usado em projetos de
eletrônica.

Com certeza você já viu esse contador em algum lugar. Ele é feito com um componente
chamado display de 7 segmentos e é composto por alguns LEDs distribuídos em segmentos, para
formação de caracteres e números. Todos os LEDs estão inseridos dentro de um mesmo
componente, onde cada pino corresponde a um terminal de um LED e há um terminal comum
correspondente ao positivo de todos os LEDs. Esse tipo de display pode ser encontrado em relógios
digitais, rádios-relógio e etc.

73
 No display existem 8 LEDs, sendo um para cada segmento (traço) e mais um para o ponto.

Note que temos 10 pinos, sendo um LED para cada segmento e 2 comuns a todos os LEDs,
sendo um de cada lado. Por mais que tenhamos 2 pinos comuns, precisamos ligar apenas 1 para
que o display funcione.

Para cada número se acende um conjunto de LEDs de forma a montar o dígito que se deseja.
Por exemplo, para fazer o número 1, acendemos os LEDs B e C. Já para o número 8, acendemos
todos.
Ligando cada um dos terminais dos LEDs a uma porta do Arduíno conseguimos controlá-los
individualmente formando caracteres e números. No projeto 14 iremos construir um contador digital
com o display de 7 segmentos mostrando os números de 0 a 9 com um intervalo de 1 segundo.

- MATERIAL NECESSÁRIO

1x Display 7 segmentos
1x Resistor 220 ohm
10x Jumper Macho-macho
1x Cabo USB
1x Placa Uno

74
- MONTAGEM DO CIRCUITO

Como se fossem vários LEDs, precisamos colocar um pino do Arduino para cada pino do
display. Como o lado positivo dos LEDs é comum a todos, precisamos de apenas 1 resistor.

- PROGRAMANDO O PROJETO CONTADOR DIGITAL

O programa, apesar de comprido, é bastante simples. Apenas acendemos e apagamos os

LEDs, conforme o número que desejamos.

1 // Decimo Quarto Projeto - Contador digital

2
3 int segE = 7;
4 int segD = 8;
5 int segC = 9;
6 int segB = 13;
7 int segA = 12;
8 int segF = 11;
9 int segG = 10;
10
11 void setup()
12 {
13 pinMode(segE, OUTPUT);

75
14 pinMode(segD, OUTPUT);
15 pinMode(segC, OUTPUT);
16 pinMode(segB, OUTPUT);
17 pinMode(segA, OUTPUT);
18 pinMode(segF, OUTPUT);
19 pinMode(segG, OUTPUT);
20 }
21
22 void loop()
23 {
24 acende0();
25 delay(1000);
26 acende1();
27 delay(1000);
28 acende2();
29 delay(1000);
30 acende3();
31 delay(1000);
32 acende4();
33 delay(1000);
34 acende5();
35 delay(1000);
36 acende6();
37 delay(1000);
38 acende7();
39 delay(1000);
40 acende8();
41 delay(1000);
42 acende9();
43 delay(1000);
44 }
45
46 void acende0()
47 {
48 digitalWrite(segE, LOW);
49 digitalWrite(segD, LOW);
50 digitalWrite(segC, LOW);
51 digitalWrite(segB, LOW);
52 digitalWrite(segA, LOW);
53 digitalWrite(segF, LOW);
54 digitalWrite(segG, HIGH);

76
55 }
56 void acende1()
57 {
58 digitalWrite(segE, HIGH);
59 digitalWrite(segD, HIGH);
60 digitalWrite(segC, LOW);
61 digitalWrite(segB, LOW);
62 digitalWrite(segA, HIGH);
63 digitalWrite(segF, HIGH);
64 digitalWrite(segG, HIGH);
65 }
66 void acende2()
67 {
68 digitalWrite(segE, LOW);
69 digitalWrite(segD, LOW);
70 digitalWrite(segC, HIGH);
71 digitalWrite(segB, LOW);
72 digitalWrite(segA, LOW);
73 digitalWrite(segF, HIGH);
74 digitalWrite(segG, LOW);
75 }
76 void acende3()
77 {
78 digitalWrite(segE, HIGH);
79 digitalWrite(segD, LOW);
80 digitalWrite(segC, LOW);
81 digitalWrite(segB, LOW);
82 digitalWrite(segA, LOW);
83 digitalWrite(segF, HIGH);
84 digitalWrite(segG, LOW);
85 }
86 void acende4()
87 {
88 digitalWrite(segE, HIGH);
89 digitalWrite(segD, HIGH);
90 digitalWrite(segC, LOW);
91 digitalWrite(segB, LOW);
92 digitalWrite(segA, HIGH);
93 digitalWrite(segF, LOW);
94 digitalWrite(segG, LOW);
95 }

77
96 void acende5()
97 {
98 digitalWrite(segE, HIGH);
99 digitalWrite(segD, LOW);
100 digitalWrite(segC, LOW);
101 digitalWrite(segB, HIGH);
102 digitalWrite(segA, LOW);
103 digitalWrite(segF, LOW);
104 digitalWrite(segG, LOW);
105 }
106 void acende6()
107 {
108 digitalWrite(segE, LOW);
109 digitalWrite(segD, LOW);
110 digitalWrite(segC, LOW);
111 digitalWrite(segB, HIGH);
112 digitalWrite(segA, LOW);
113 digitalWrite(segF, LOW);
114 digitalWrite(segG, LOW);
115 }
116 void acende7()
117 {
118 digitalWrite(segE, HIGH);
119 digitalWrite(segD, HIGH);
120 digitalWrite(segC, LOW);
121 digitalWrite(segB, LOW);
122 digitalWrite(segA, LOW);
123 digitalWrite(segF, HIGH);
124 digitalWrite(segG, HIGH);
125 }
126 void acende8()
127 {
128 digitalWrite(segE, LOW);
129 digitalWrite(segD, LOW);
130 digitalWrite(segC, LOW);
131 digitalWrite(segB, LOW);
132 digitalWrite(segA, LOW);
133 digitalWrite(segF, LOW);
134 digitalWrite(segG, LOW);
135 }
136 void acende9()

78
137 {
138 digitalWrite(segE, HIGH);
139 digitalWrite(segD, LOW);
140 digitalWrite(segC, LOW);
141 digitalWrite(segB, LOW);
142 digitalWrite(segA, LOW);
143 digitalWrite(segF, LOW);
144 digitalWrite(segG, LOW);
145 }

- POSSÍVEIS ERROS

Caso o projeto não funcione, verifique alguns dos possíveis erros:

• Caso o display não acenda nenhum LED, verifique a ligação do pino comum;
• Caso o display não acenda algum segmento, verifique a ligação desse segmento;
• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduíno;
• Verifique se o código carregou na placa através da IDE Arduíno

79
 DÉCIMO QUINTO PROJETO – DADO ELETRÔNICO

Vamos construir um dado que rola ao sentir movimento. Para este projeto, iremos juntar
dois componentes que já vimos anteriormente, um display de 7 segmentos e um sensor de vibração
tilt.
Ao agitar o sensor de vibração tilt, o display deverá mostrar números aleatórios até parar,
simulando o funcionamento de um dado de 10 lados.

- MATERIAL NECESSÁRIO

1x Display 7 segmentos
1x Resistor 220 ohm
1x Sensor tilt
13x Jumper Macho-macho
1x Cabo USB
1x Placa Uno

- MONTAGEM DO CIRCUITO

Para que o projeto funcione adequadamente é necessário ajustar o sensor de vibração tilt
através do pequeno potenciômetro azul, girando-o totalmente para direita como indicado pela seta
vermelha. Se precisar, use a chave que veio junto do kit.

80
- PROGRAMANDO O PROJETO DADO ELETRÔNICO

Este programa é diferente do projeto que utiliza o Buzzer porque dessa vez, em vez de tocar
um Buzzer ao se movimentar, gera um número aleatório. O funcionamento e a programação do
display de 7 segmentos são os mesmos vistos no Projeto anterior.

1 // Decimo Quinto Projeto - Dado eletrônico

2
3 int segE = 7;
4 int segD = 8;
5 int segC = 9;
6 int segB = 13;
7 int segA = 12;
8 int segF = 11;
9 int segG = 10;
10
11 int pinoTilt = 5;
12
13 void setup()
14 {
15 pinMode(segE, OUTPUT);
16 pinMode(segD, OUTPUT);
17 pinMode(segC, OUTPUT);
18 pinMode(segB, OUTPUT);
19 pinMode(segA, OUTPUT);
20 pinMode(segF, OUTPUT);
21 pinMode(segG, OUTPUT);
22
23 pinMode(pinoTilt, INPUT);
24 }
25
26 void loop()
27 {
28
29 if(digitalRead(pinoTilt) == HIGH)
30 {
31 jogaDado();
32 }
33 }
34
35 void jogaDado()

81
36 {
37 for(int i=0; i<25; i++) // Mostra 24 numeros
38 {
39 switch(random(0, 9)) // Escolhe um numero aleatorio entre 0 e 9
40 {
41 case 0 :
42 acende0();
43 break;
44 case 1 :
45 acende1();
46 break;
47 case 2 :
48 acende2();
49 break;
50 case 3 :
51 acende3();
52 break;
53 case 4 :
54 acende4();
55 break;
56 case 5 :
57 acende5();
58 break;
59 case 6 :
60 acende6();
61 break;
62 case 7 :
63 acende7();
64 break;
65 case 8 :
66 acende8();
67 break;
68 case 9 :
69 acende9();
70 break;
71 }
72 delay(4*i); // O delay aumenta conforme passam mais numeros
73 }
74 }
75
76 void acende0()

82
77 {
78 digitalWrite(segE, LOW);
79 digitalWrite(segD, LOW);
80 digitalWrite(segC, LOW);
81 digitalWrite(segB, LOW);
82 digitalWrite(segA, LOW);
83 digitalWrite(segF, LOW);
84 digitalWrite(segG, HIGH);
85 }
86 void acende1()
87 {
88 digitalWrite(segE, HIGH);
89 digitalWrite(segD, HIGH);
90 digitalWrite(segC, LOW);
91 digitalWrite(segB, LOW);
92 digitalWrite(segA, HIGH);
93 digitalWrite(segF, HIGH);
94 digitalWrite(segG, HIGH);
95 }
96 void acende2()
97 {
98 digitalWrite(segE, LOW);
99 digitalWrite(segD, LOW);
100 digitalWrite(segC, HIGH);
101 digitalWrite(segB, LOW);
102 digitalWrite(segA, LOW);
103 digitalWrite(segF, HIGH);
104 digitalWrite(segG, LOW);
105 }
106 void acende3()
107 {
108 digitalWrite(segE, HIGH);
109 digitalWrite(segD, LOW);
110 digitalWrite(segC, LOW);
111 digitalWrite(segB, LOW);
112 digitalWrite(segA, LOW);
113 digitalWrite(segF, HIGH);
114 digitalWrite(segG, LOW);
115 }
116 void acende4()
117 {

83
118 digitalWrite(segE, HIGH);
119 digitalWrite(segD, HIGH);
120 digitalWrite(segC, LOW);
121 digitalWrite(segB, LOW);
122 digitalWrite(segA, HIGH);
123 digitalWrite(segF, LOW);
124 digitalWrite(segG, LOW);
125 }
126 void acende5()
127 {
128 digitalWrite(segE, HIGH);
129 digitalWrite(segD, LOW);
130 digitalWrite(segC, LOW);
131 digitalWrite(segB, HIGH);
132 digitalWrite(segA, LOW);
133 digitalWrite(segF, LOW);
134 digitalWrite(segG, LOW);
135 }
136 void acende6()
137 {
138 digitalWrite(segE, LOW);
139 digitalWrite(segD, LOW);
140 digitalWrite(segC, LOW);
141 digitalWrite(segB, HIGH);
142 digitalWrite(segA, LOW);
143 digitalWrite(segF, LOW);
144 digitalWrite(segG, LOW);
145 }
146 void acende7()
147 {
148 digitalWrite(segE, HIGH);
149 digitalWrite(segD, HIGH);
150 digitalWrite(segC, LOW);
151 digitalWrite(segB, LOW);
152 digitalWrite(segA, LOW);
153 digitalWrite(segF, HIGH);
154 digitalWrite(segG, HIGH);
155 }
156 void acende8()
157 {
158 digitalWrite(segE, LOW);

84
159 digitalWrite(segD, LOW);
160 digitalWrite(segC, LOW);
161 digitalWrite(segB, LOW);
162 digitalWrite(segA, LOW);
163 digitalWrite(segF, LOW);
164 digitalWrite(segG, LOW);
165 }
166 void acende9()
167 {
168 digitalWrite(segE, HIGH);
169 digitalWrite(segD, LOW);
170 digitalWrite(segC, LOW);
171 digitalWrite(segB, LOW);
172 digitalWrite(segA, LOW);
173 digitalWrite(segF, LOW);
174 digitalWrite(segG, LOW);
175 }

- POSSÍVEIS ERROS

Caso o projeto não funcione verifique alguns dos possíveis erros:

• Verifique se os jumpers estão na mesma coluna dos terminais dos componentes, fazendo
assim a conexão;
• Verifique se os jumpers estão ligados nos pinos corretos no Arduíno;
• Certifique-se de ter girado o potenciômetro do sensor todo para direita como indicado na
montagem;
• Verifique se o código carregou na placa através da IDE Arduíno.

85
 CONCLUSÃO

Parabéns, você concluiu os 15 projetos propostos para o nosso guia!

Agora que você já possui um pouco mais de intimidade com eletrônica e programação, se
sente seguro para criar algo? Se você precisa de mais de treino, o nosso possui diversos kits com
projetos que vão desde o super-básico até o mais avançado. Nesta última aula separamos alguns
projetos que podem ser interessantes para quem acabou de ter o primeiro contato com o Arduíno.
Alguns componentes que não trabalhamos tanto no guia foram os sensores, vimos apenas
o de vibração e o de luminosidade, mas existe sensor para quase tudo que você possa imaginar!
Com eles é possível realizar diversos projetos, como os listados abaixo:

• Sensor de temperatura
• Sensor de proximidade, que mede a distância utilizando ultrassom
• Sensor de toque para tocar músicas
• Sensor de umidade do solo, para saber quando a sua planta precisa de água
• Sensor de chamas, tome cuidado com os testes desse sensor

Além dos sensores, outros componentes legais de se aprender a mexer são os motores. No
guia vimos como funciona o servo motor, mas é interessante também conhecer o motor de corrente
contínua, mais simples, ou mesmo o motor de passo.
Para interagir com o Arduíno, é interessante colocar um display em alguns projetos. Vimos o display
de 7 segmentos, que é bem simples. Existem outros modelos com mais espaço para se escrever,
como o Display LCD e o Display OLED.

Claro que a partir de um projeto de exemplo você pode acrescentar outros sensores e aplicar
uma lógica diferente da proposta, assim o seu projeto vai atender melhor a sua necessidade. Se
você quiser aprender mais sobre como programar, precisando trabalhar um pouco melhor com a
lógica de programação.

86
 Sem dúvida o Arduíno é uma plataforma incrível e a quantidade de projetos possíveis de
serem feitos é praticamente infinita. Esperamos que, ao longo do desenvolvimento dos 15 projetos
do kit, você tenha compreendido os primeiros passos com Arduíno e que o guia tenha sido
esclarecedor. O principal objetivo é, na verdade, despertar a sua curiosidade e fazer você criar seus
próprios projetos.

A gente se vê por aí!

Até a próxima viajem pelo mundo IOT.

87