Curso Básico de Arduino

Curso Básico de Arduino
TÓPICOS AVANÇADOS DE PROGRAMAÇÃO
Marcelo Felipe Moreira Persegona e Luiz Felipe Marcolino Persegona
Curso Básico de Arduino | Brasília/DF, março de 2023
1
Sumário
Sobre os autores ................................................................................................................................... 3
O que é Arduino? .................................................................................................................................. 4
O que são shields? ............................................................................................................................... 6
Componentes da placa Arduino........................................................................................................ 7
Instalando a IDE do Arduino no Windows .................................................................................... 16
Placa de Ensaio ou Protoboard ....................................................................................................... 19
Conhecendo o ambiente de trabalho do TinkerCad .................................................................. 22
Aula 01 - Hello, World! ....................................................................................................................... 26
Aula 02 - LED com botão liga desliga ............................................................................................ 28
Aula 03 - Controlar um LED com um potenciômetro ................................................................. 34
Aula 04 - Botão que acende LED-s com efeito ............................................................................ 40
Aula 05 - Controlando 8 LED-s com CI74HC595 e fazendo contagem binária ................... 47
Aula 06 - Piscar um LED com efeito fader .................................................................................... 52
Aula 07 - Sinal de trânsito ................................................................................................................. 56
Aula 08 - Dois sinais de trânsito sincronizados.......................................................................... 61
Aula 09 - Controlando LED RGB multicolorido ........................................................................... 70
Aula 10 - Controlar as cores de um LED RGB com botões ..................................................... 76
Aula 11 - Sensor de luz LDR com saída de leitura em LED-s .................................................. 84
Aula 12 - Emitir sons com o buzzer ................................................................................................ 87
Aula 13 - Controlando dois servomotores com potenciômetros ........................................... 92
Aula 14 - Controlando um servomotor com potenciômetro .................................................... 95
Aula 15 - Controlar a velocidade de um motor CC com potenciômetro ............................... 98
Aula 16 - Motor CC com controle de velocidade, LED-s medidores de potência e buzzer
para alerta de potência máxima .................................................................................................... 102
Aula 17 - Alarme com sensor de movimentos PIR ................................................................... 107
Aula 18 - Display LCD - Hello World ............................................................................................. 110
Aula 19 - Display LCD com dois potenciômetros ..................................................................... 113
Aula 20 - Display LCD com sensor de temperatura e luminosidade ................................... 119
Aula 21 - Display LCD com dois potenciômetros e servomotor controlado com um
potenciômetro .................................................................................................................................... 125
Aula 22 - Relógio simples com display LCD .............................................................................. 130
Aula 23 - Montagem de relógio com módulo DS1302RTC ..................................................... 133
Aula 24 - Sensor de obstáculos ultrassônico HC-SRO4 ......................................................... 138
Aula 25 - Carro robótico com sensor de obstáculo e servomotor ....................................... 143
Aula 26 - Carro robótico controlado com controle remoto infravermelho ........................ 147
Aula 27 - Braço robótico com 4 servomotores controlados com potenciômetros ......... 151
Aula 28 - Calculadora ....................................................................................................................... 158
2
Sobre os autores
Marcelo Felipe Moreira Persegona é doutor em Política e

Gestão Ambiental pela Universidade de Brasília (2010) e
mestre em Desenvolvimento Sustentável com ênfase em
Política e Gestão de Ciência e Tecnologia pela Universidade
de Brasília (2005) e graduado em Ciência da Computação
pela Universidade Católica de Brasília (1998). Atualmente, é
Assessor de Planejamento e Gestão do Conselho Federal de
Enfermagem (Cofen), professor da Faculdade de Tecnologia
e Inovação Serviço Nacional de Aprendizagem Comercial
(Senac) do Distrito Federal, pesquisador da Universidade de
Brasília nos temas de Ciência e Tecnologia e Desenvolvimento Sustentável. Tem
experiência nas áreas de Ciência da Computação, Planejamento Estratégico e Meio
Ambiente, atuando principalmente nos seguintes temas: Planejamento e Gestão,
Desenvolvimento Sustentável, Política e Gestão de Ciência e Tecnologia, Política e
Gestão Ambiental, Gestão do Conhecimento, Gestão da Informação, Tecnologia da
Informação e Comunicação, Sistemas de Informações Geográficas (SIG) e MapServer.
Luiz Felipe Marcolino Persegona é estudante do Colégio Militar de Brasília

(CMB), cursa o ensino fundamental, 6ª série (2019), e entusiasta de
Tecnologia da Informação. Elaborou às dez primeiras aulas desta
apostila. Tem experiência nas áreas de Python, C++, PHP, Java,
JavaScript e Arduino, nas quais já desenvolveu vários programas.
3
O que é Arduino?
O Arduino é uma plataforma eletrônica de código aberto baseada em hardware e

software1 fáceis de usar em uma plataforma de prototipagem eletrônica de hardware
livre e de placa única, projetada com um microcontrolador ATMel AVR com suporte de
entrada/saída embutido. Sua linguagem é essencialmente C/C++.
Então Arduino é um conjunto de ferramentas para facilitar o desenvolvimento de

dispositivos eletrônicos. Nessa plataforma estão incluídos o software de programação,
a IDE do Arduino (ou ambiente de desenvolvimento de códigos), e as placas que serão
programadas para serem usadas no projeto, como o Arduino UNO.
Além disso, todas essas ferramentas são de código aberto, ou seja, qualquer
pessoa pode replicá-las ou contribuir para o seu aperfeiçoamento, respeitando algumas
regras. Isso é o que permite o surgimento de diversas placas compatíveis, melhoradas
e para as mais diversas aplicações. São todas essas ferramentas que nos permitem
interagir com uma série de componentes eletrônicos para desenvolver uma infinidade
de projetos.
O material aqui coletado ajudará a você aprender sobre essa plataforma que vem
revolucionando o aprendizado da eletrônica:
• Site oficial do Arduino
https://www.arduino.cc
• Site emulador de Arduino
https://www.tinkercad.com/circuits
http://fritzing.org/download/
http://snap4arduino.org
• Local para baixar o driver da porta USB, caso não seja reconhecida no Plug
& Play do Windows (ownload do drive USB2.0-Serial CH34x)
https://sparks.gogo.co.nz/ch340.html
• Lojas físicas e virtuais para compra de placa Arduino e componentes
https://www.huinfinito.com.br
https://www.contatopro.com.br/
https://www.robocore.net/loja/shields-para-arduino
O primeiro Arduino surgiu por volta de 2005, na Itália, e a idéia era disponibilizar
um microcontrolador barato e fácil de se usar, voltado para hobistas, estudantes e
profissionais, que possibilitasse que esse grupo de pessoas construísse sistemas de
1 Entenda hardware como as placas e software como o programa de computador.

4
hardware e software que interagissem com o mundo real por meio de sensores ou
outros componentes eletrônicos recebendo as entradas, e por atuadores produzindo as
saídas.
Por exemplo, em um projeto com um servomotor e um potenciômetro no Arduino,

tem-se um componente eletrônico recebendo uma entrada que seria a movimentação
do seu eixo, e um servomotor, como atuador, produzindo uma saída que são os
movimentos do seu braço de acordo com a movimentação do potenciômetro, e o
Arduino realizando o processamento que transforma o movimento do eixo do
potenciômetro em movimentos do braço do servomotor.
Então, pode-se dizer que o Arduino é um microcontrolador com diversos

facilitadores para o microcontrolador ATMega.
Com um Arduino somos capazes de criar uma infinidade de projetos, como

alarmes, controladores de iluminação, braços robóticos, um robô inteiro, controlador de
telas sensíveis ao toque, controlar motores e muitas outras coisas.
O conjunto formado pelo: Arduino, IDE de programação e linguagem de

programação, é chamado Wiring. O Wiring é open-source e é conhecido como
plataforma de desenvolvimento ou plataforma de prototipação. Muitas pessoas
confundem a definição de Wiring com a definição do Arduino, contudo, o Arduino faz
parte do Wiring e é apenas um microcontrolador com hardware open-source.
Placa Arduino UNO Original da Itália à esquerda e Arduino IDE à direita.
Os programas escritos para o Arduino são chamados de sketch

(esboço/rascunho) e são escritos em linguagem C e C++. A IDE do Arduino vem com
uma biblioteca composta por um conjunto de funcionalidades que facilitam o trabalho
de programação. Escrever programas para o Arduino é fácil, e tratando de modo
genérico, precisa-se apenas definir o que o método setup() e o método loop() vão fazer.
O método setup() é executado uma vez assim que o Arduino é ligado e

normalmente é usado para definir configurações iniciais, como por exemplo quais serão
os pinos de entrada ou de saída do Arduino. O método loop() é executado após o
método setup(), e como diz o próprio nome ele é executado em loop enquanto o Arduino
estiver ligado. Dentro do método loop é onde normalmente é escrito as funcionalidades
do programa, como por exemplo, fazer um LED piscar de dois em dois segundos.
5
O Arduino possui várias versões, dentre elas pode-se destacar: Arduino UNO,
Arduino Leonardo, Arduino Due, Arduino Yún, Arduino Micro, Arduino Mega, Arduino
Fio, Arduino Tre, Arduino Zero e muitas outras. E recomendado iniciar com Arduino
UNO R3.
Para começar os projetos com Arduino é necessária uma placa Arduino, um

computador para programá-lo, uma protoboard e os componentes eletrônicos
necessários para a construção do seu projeto.
O que são shields?

Os shields são placas de expansão conectadas ao Arduino para obter
funcionalidades específicas como: controlar motores, GPS, redes Wi-Fi, Wireless,
leitoras de cartão SD, bluetooth, MP3 player, joystick e muito mais. Vários shields
podem ser conectados ao Arduino ao mesmo tempo.
6
Componentes da placa Arduino
Existe uma grande variedade de placas Arduino que podem ser utilizadas para
diferentes propósitos. Algumas placas podem ser diferentes da placa abaixo, mas a
maioria das placas Arduino possui os componentes listados.
Alimentação (USB/Conector P4)

Cada placa Arduino precisa de uma maneira de ser conectada à uma fonte de
energia. O Arduino UNO pode ser alimentado a partir de um cabo USB proveniente do
seu computador ou a partir de uma fonte de alimentação de parede que é terminada
em um conector P4. Na imagem acima, a conexão USB (2) e a entrada do P4 (7).
A conexão USB também é por onde será carregado o código na placa Arduino.
NOTA 1: NÃO use uma fonte de alimentação superior a 15 V, pois você irá superar a
tensão máxima do seu Arduino e assim irá queimá-lo. A tensão recomendada para a
maioria dos modelos Arduino é de 6 V a 12 V.
7
NOTA 2: quando alimentar a sua placa por uma fonte externa, verifique que o terminal
positivo (+) é o terminal interno do conector P4.
Pinos (5V, 3V3, GND, Analógicos, Digitais, PWM, AREF)
Os pinos na placa Arduino são os lugares onde se conecta os fios para construir
um circuito, em conjunto com uma protoboard. O Arduino tem vários tipos diferentes de
pinos, cada um dos quais é rotulado na placa e usado para diferentes funções.
GND (3): abreviação de "ground" (terra em inglês). Existem vários pinos de GND
no Arduino, qualquer um deles pode ser utilizado para aterrar o circuito.
5V (4) e 3V3 (5): o pino de 5V fornece 5 volts de energia e o pino de 3V3 fornece
3,3 volts. A maioria dos componentes simples usados com o Arduino trabalham
felizmente com 5 V ou 3,3 V;
Analógico (6): a área dos pinos rotulada com "ANALOG IN" (A0 a A5 no UNO) é
para os pinos analógicos. Esses pinos podem ler o sinal de um sensor analógico (como
um sensor de luminosidade) e convertê-lo em um valor digital para usar no código.
Digital (7): a área dos pinos rotulada com "DIGITAL" (0 a 13 no UNO) é para os
pinos digitais. Esses pinos podem ser usados tanto para entrada digital (como dizer se
um botão está pressionado) como para saída digital (como alimentar um LED).
PWM (8): o til (~) ao lado de alguns dos pinos digitais (3, 5, 6, 9, 10 e 11 no UNO)
atuam como pinos digitais normais, mas também podem ser utilizados para algo
chamado Modulação por Largura de Pulso (PWM). Esses pinos são capazes de atuar
como uma "saída analógica" (podendo controlar a intensidade de um LED, por
exemplo).
NOTA: geralmente os pinos analógicos do Arduino podem também ser usados

como entrada ou saída digital (isso vale para A0 a A5 no UNO).
8
Botão de reset
Assim como a Nintendo original, o Arduino possui um botão de reinicialização (9).

Empurrando, ele conectará temporariamente o pino de reset (RST) ao GND e reiniciará
o programa carregado no Arduino. Isso pode ser muito útil se o seu código não repetir,
mas você quer testá-lo várias vezes.
NOTA: o reset não apaga o código carregado na placa, ele serve para reiniciar a
execução do programa.
LED indicador de energia
Ao centro da placa existe um pequeno LED ao lado da palavra "ON" (10). Este
LED deve acender sempre que ligar o Arduino a uma fonte de energia. Se esta luz não
ligar, há uma boa chance de haver algo errado. Verifique o seu circuito!
LED-s TX e RX
TX é a abreviação para transmitir, o RX é a sigla para receber. Essas marcas
aparecem um pouco na eletrônica para indicar os pinos responsáveis pela comunicação
serial. No nosso caso, há dois lugares no Arduino UNO onde TX e RX aparecem: uma
vez ao lado dos pinos digitais 0 e 1, e uma segunda vez ao lado dos LED-s indicadores
TX e RX (11). Esses LED-s nos darão algumas boas indicações visuais sempre que
nosso Arduino estiver recebendo ou transmitindo dados. Por exemplo quando estamos
carregando um novo programa na placa.
9
CI principal
O maior componente da placa, com várias pernas metálicas, é um CI, ou circuito
integrado (12). É nele que o código é executado e todos os dados são processados. O
CI principal no Arduino é diferente entre modelos de placa, mas geralmente é da linha
ATmega de microcontroladores da empresa Atmel (agora Microchip).
Reguladores de tensão
Os reguladores de tensão não são realmente algo que se deva mexer no Arduino.
Mas é útil saber que estão lá e para que servem. Os reguladores de tensão fazem
exatamente o que o nome diz, eles controlam a tensão interna da sua placa Arduino.
Ele faz com que a tensão do circuito seja sempre a mesma, independente da tensão
de alimentação.
10
Módulos para placa Arduino
11
Geekcreit® UNO R3
Kit básico de aprendizagem inicial atualização da versão
para Arduino
Característica:
Esta é uma versão atualizado do UNO R3 kit para inicial, adiciona mais
componentes para obter mais recursos e experimentar.
Você aprenderá por meio da construção de vários projetos criativos.

Iniciando o básico da eletrônica, para fazer projetos mais complexos, o kit irá ajudá-lo
a controlar o mundo físico com sensor e atuadores.
Incluído no pacote:
1 x Placa de desenvolvimento UNO R3 compatível com Arduino

1 x Cabo USB
1 x Placa de extensão do protótipo
1 x Mini placa de ensaio
1 x Motor passo a passo 5V
1 x Placa de motorista de motor stepper 2003
10 x LED vermelho
10 x LED verde
10 x LED azul
2 x Sensor de vibração
1 x Sensor de chama
1 x Sensor de temperatura LM35
1 x Receptor infravermelho
3 x Fotorresistor
4 x Tampa da tecla
4 x Interruptor de chave
1 x Potenciômetro ajustável
1 x Buzzer passivo (zumbador piezo)
1 x Buzzer ativo (gerador de tom)
1 x Boné de jumper
1 x Painel grande
1 x Controle Remoto
1 x 1602 Tela
1 x Servos 9G
1 x Caixa de componentes
1 x 10p linha DuPont
30 x Linha de placa de ensaio(aprox.)
1 x Resistência 220ohm
1 x 8*8 matriz de pontos
1 x Tubo de oito dígitos de um dígito
1 x Quatro dígitos tubo de oito segmentos
1 x IC 74HC595
1 x Suporte da bateria
1 x Plug de resistor de 1K
1 x Plug de resistor 10K
1 x Bateria de 9V
1 x 2,54mm cabeçalho de pinos de 40 pinos
12
13
https://www.tinkercad.com/learn
http://www.comofazerascoisas.com.br/projeto-arduino-led-com-botao-liga-desliga.html
http://www.comofazerascoisas.com.br/marcadores/Arduino+Uno+R3
http://www.comofazerascoisas.com.br/projeto-arduino-controlando-led-rgb-
multicolorido.html
http://www.comofazerascoisas.com.br/projeto-arduino-com-display-lcd.html
http://www.comofazerascoisas.com.br/circuito-simples-que-controla-a-velocidade-de-
um-motorzinho-como-fazer.html
http://www.comofazerascoisas.com.br/projeto-arduino-com-display-lcd-sensor-de-
temperatura-e-sensor-de-luz.html
http://www.comofazerascoisas.com.br/motor-cc-no-arduino-com-controle-de-
velocidade-e-leds-medidores-de-potencia.html
http://www.comofazerascoisas.com.br/joystick-controlando-3-servomotores-no-
arduino.html
http://www.comofazerascoisas.com.br/guincho-robotico-de-palito-de-picole-com-
arduino-e-servomotores-como-fazer.html
http://www.comofazerascoisas.com.br/como-fazer-um-mini-gerador-de-energia-
aeolica-versao-2.html
http://www.comofazerascoisas.com.br/como-fazer-um-aviao-bimotor-de-palitos-de-
picole.html
http://www.comofazerascoisas.com.br/arduino-com-sensor-de-obstaculos-ultrasonico-
HC-SRO4.html
http://www.comofazerascoisas.com.br/como-fazer-um-alarme-com-arduino-sensor-de-
movimentos-pir.html
http://www.comofazerascoisas.com.br/controlando-a-velocidade-de-um-motor-cc-no-
arduino-com-potenciometro.html
https://www.instructables.com/id/Smartphone-Controlled-RC-Car-Using-Arduino/
https://www.instructables.com/id/Arduino-CNC-Plotter-DRAWING-MACHINE/
https://www.instructables.com/id/Sensor-Stations-Network-for-Lighting-and-Security-/
https://www.instructables.com/id/Arduino-Bluetooth-Controlled-Robot-Car-1/
https://www.instructables.com/id/Arduino-Robot-Arm-3/
https://www.instructables.com/id/Mini-CNC-Laser-Wood-Engraver-and-Paper-Cutter/
https://www.instructables.com/id/DoggoBot-Version-1/
https://www.instructables.com/id/Radar-Gr%C3%A1fico-Con-Arduino-Y-Processing/
14
https://www.instructables.com/id/Electric-Analog-Piano/
https://www.instructables.com/id/How-to-Build-a-GPS-Guided-Robot/
https://www.instructables.com/id/Arduino-CNC-Drawing-Machine-or-the-Road-to-
Success/
https://www.instructables.com/id/How-to-Make-a-Drone-Using-Arduino-Make-a-
Quadcopte/
https://www.instructables.com/id/DIY-Arduino-Drawing-Machine/
https://www.instructables.com/id/How-to-Make-a-Line-Follower-Using-Arduino/
https://www.instructables.com/id/Yet-Another-Balancing-Robot/
https://www.instructables.com/id/Arduino-Camera-Stabilizer-DIY/
https://randomnerdtutorials.com/projects/#home-automation
https://www.hackster.io/petoi/opencat-845129
http://www.techmonkeybusiness.com/ps2-controller-sketch-for-escs-and-stuff.html
15
Instalando a IDE2 do Arduino no Windows
Aqui será explicado como instalar a IDE do Arduino no sistema operacional

Windows.
Pimeiro baixe o programa da IDE do Arduino do link abaixo:
https://www.arduino.cc/en/Guide/Windows?setlang=en#toc1
Caso necessite de mais ajuda, segue o link das instruções de instalação:
https://www.arduino.cc/en/Guide/Windows?setlang=en#toc2
Baixando o programa do Arduino (IDE)
Baixe a versão mais atualizada na página de download. Lá, você poderá escolher
o tipo de instalação que deseja realizar, .exe ou Zip. Sugiro que escolha a primeira
opção que faz a instalação com tudo que você vai precisar para utilizer a IDE do
Arduino, inclusive os drivers da placa Arduino. A versão do pacote Zip exigirá que você
faça a instalação dos drivers da placa Arduino manualmente. A versão Zip é muito útil
se você quiser fazer a instlação do tipo portátil.
Quando terminar de baixar o arquivo, proceda a instalação e siga os passos

indicados pelo programa e escolha a instalação do driver sugerido na interface para o
sistema operacional que está instalado no seu computador. Escolha os components a
serem instlados.
2
Integrated Development Environment (IDE) ou Ambiente de Desenvolvimento Integrado, é um
programa de computador que reúne características e ferramentas de apoio ao desenvolvimento de
software com o objetivo de agilizar este processo.
16
Escolha o diretório de instlação, sugiro que utilize o diretório sugerido pelo
programa de instalçao, conforme figura abaixo:
O processo de instalação irá extrair e instalar os arquivos necessários para a

correta execução da IDE do Arduino no diretório selecionado.
17
Antes de começar, escolha a placa Arduino que irá utilizar na barra de ferramentas
da IDE do Arduino, selecione “Ferramentas”, depois “Placa” e selecione o tipo de placa
que irá utilizar. Geralmente a mais utilizada é a “Arduino UNO R3” ou simplemente
“Arduino UNO”.
18
Placa de Ensaio ou Protoboard
O QUE VAMOS FAZER?
Conhecer o a Placa de Ensaio (Protoboard).
O QUE É A PLACA DE ENSAIO?

Uma placa de ensaio ou matriz de contato ou protoboard é uma placa com furos
e conexões condutoras ultilizada para a montagem de protótipos e projetos em estado
inicial. A grande vantagem da placa de ensaio na montagem de circuitos eletrônicos é
a facilidade de inserção de componentes, uma vez que não necessita soldagem. As
placas variam de 800 furos até 6000 furos, tendo conexões verticais e horizontais.
Porém, a sua grande desvantagem é o seu "mau-contato", e muitas vezes a pessoas
preferem montar os seus circuitos com muitos fios a usar a protoboard.
No TinkerCad possui três tipos de Placa de Ensaio:
Placa de Ensaio pequena
Placa de Ensaio média
19
Placa de Ensaio grande
Na superfície de uma matriz de contato há uma base de plástico em que existem

centenas de orifícios onde são encaixados os componentes. Em sua parte inferior, são
instalados contatos metálicos que interligam eletricamente os componentes inseridos
na placa. Geralmente suportam correntes entre 1 A e 3 A.
CONHECENDO COMO FUNCIONA UMA PLACA DE ENSAIO

Placas de ensaio sem solda são disponibilizadas por vários fabricantes diferentes,
mas a maioria compartilha um layout similar. O layout típico de uma placa de ensaio é
composto de duas áreas, chamadas de tiras ou faixas que consistem em terminais
elétricos interligados.
FAIXAS DE TERMINAIS
São as faixas de contatos no qual são instalados os componentes

eletrônicos.
Nas laterais das placas geralmente existem duas trilhas de contatos

interligadas verticalmente. Na faixa vertical no centro da placa de ensaio há
um entalhe para marcar a linha central e fornecer um fluxo de ar para
possibilitar um melhor arrefecimento de circuitos integrados (CI-s) e outros
componentes ali instalados. Entre as faixas laterais e o entalhe central existem
trilhas de cinco contatos dispostas paralelamente e interligadas
horizontalmente.
As cinco colunas de contatos do lado esquerdo do entalhe são

frequentemente marcados como A, B, C, D, e E, enquanto os da direita são
marcados F, G, H, I e J, os CI-s devem ser encaixados sobre o entalhe central,
com os pinos de um lado na coluna E, enquanto os pinos da outra lateral são
fixados na coluna F, do outro lado do entalho central.
20
FAIXAS DE BARRAMENTOS
São usadas para o fornecimento de tensão ao circuito, constituídas de

duas colunas nas laterais, uma utilizada para o condutor negativo ou terra,
e outra para o positivo. Normalmente a coluna que se destina a distribuição
da tensão de alimentação está marcada em vermelho, enquanto a coluna
destinada ao fio terra está marcada em azul ou preta.
Alguns projetos modernos de placas de ensaio possuem um controle

maior sobre a indutância gerada nos barramentos de alimentação, protegendo
o circuito de ruídos causados pelo eletromagnetismo.
Você pode observar na figura, a placa de montagem possui a matriz principal em

seu meio e duas linhas superiores e duas inferiores em cada matriz (alguns possuem
apenas uma linha). Nestes últimos, os contatos estão na horizontal, enquanto na matriz
principal eles estão na vertical. Em outras palavras, as linhas isoladas se conectam com
os furos de baixo e as linhas agrupadas se conectam com os furos do lado. A placa de
ensaio é bastante usada em escolas de ensino técnico, para os alunos terem seus
primeiros contatos com a eletrônica visto que não precisa de soldagem de
componentes.
Vamos começar nossos exercícios para saber como a placa de ensaio funciona.
21
Conhecendo o ambiente de trabalho do TinkerCad
O QUE VAMOS FAZER?
Conhecer o ambiente de trabalho do Tinker Cad.
https://www.tinkercad.com/
O QUE É O TINKERCAD?
O Tinkercad é uma plataforma online que permite aos usuários projetar e simular
modelos 3D. É uma ferramenta gratuita e fácil de usar, projetada para iniciantes e
especialistas. Com o Tinkercad, os usuários podem criar modelos 3D de objetos,
edifícios e muito mais e, em seguida, exportá-los para impressão 3D ou usá-los em
outros projetos.
A Tinkercad foi fundada como uma empresa em 2010 na União Europeia pelo ex-
engenheiro do Google Kai Backman e seu cofundador Mikko Mononen, com o objetivo
de tornar a modelagem 3D, especialmente o design de itens físicos, acessível ao
público em geral, e permitir que os usuários publiquem seus projetos sob uma licença
Creative Commons.
Em 2011 a página tinkercad.com foi lançada como uma ferramenta de modelagem

3D baseada na web para navegadores habilitados para WebGL, e em 2012 a empresa
mudou sua sede para São Francisco, Califórnia. Em 2012 mais de 100.000 projetos 3D
foram publicados por usuários. Em maio de 2013 a Autodesk anunciou na Maker Faire
que iria adquirir o Tinkercad.
Em março de 2017 a Autodesk recomendou que os usuários do 123D Sculpt, a

ser aposentado em breve, migrassem para o Tinkercad (ou Maya LT). Em maio a
Autodesk interrompeu seu 123D Circuits (Circuits.io) "Electronics Lab". Os recursos do
programa foram integrados ao Tinkercad.
Uma das coisas mais interessantes sobre o Arduino e o Tinkercad é que eles
podem ser usados juntos. O Tinkercad possui uma gama de componentes eletrônicos
que podem ser usados para construir circuitos e dispositivos de controle, e também
possui um simulador de Arduino embutido que permite aos usuários programar e testar
seus circuitos em um ambiente virtual. Isso torna mais fácil prototipar e testar novas
ideias antes de construí-las no mundo real.
O Autodesk Tinkercad Circuito é uma poderosa ferramenta online para projetar e

simular circuitos eletrônicos. Faz parte do conjunto de ferramentas Tinkercad que
permite aos usuários criar projetos 3D, circuitos e códigos em uma única plataforma. O
Circuito Tinkercad é ideal para iniciantes que desejam aprender eletrônica e
programação, bem como profissionais que desejam prototipar e testar rapidamente
seus projetos antes de construí-los no mundo real.
O Autodesk Tinkercad Circuito fornece uma interface simples de arrastar e soltar

para projetar circuitos. Possui uma biblioteca de componentes eletrônicos como
22
resistores, capacitores, LED-s e microcontroladores que podem ser facilmente
adicionados ao circuito. Os componentes podem ser conectados entre si usando fios
virtuais para criar um circuito completo. A ferramenta também fornece um recurso de
simulação que permite aos usuários testar seu circuito antes de construí-lo. O recurso
de simulação pode ser usado para medir tensão, corrente e resistência, e também pode
ser usado para solucionar problemas com o circuito.
Além de projetar circuitos, o Tinkercad Circuit também fornece um editor de código

que permite aos usuários programar seus circuitos. Ele suporta linguagens de
programação como C++, JavaScript e Python. Os usuários podem escrever códigos
para controlar seus circuitos e criar projetos interativos, como robôs, alarmes e outros
dispositivos. O editor de código também inclui um monitor serial embutido que permite
aos usuários enviar e receber dados de seu circuito.
O Autodesk Tinkercad Circuito é uma excelente ferramenta para uso educacional,

pois oferece uma maneira divertida e envolvente para os alunos aprenderem sobre
eletrônica e programação. Possui uma variedade de planos de aula e tutoriais que
abrangem tópicos como design de circuitos, programação e robótica. A ferramenta
também é ideal para fabricantes que desejam prototipar e testar rapidamente seus
designs antes de construí-los.
Em conclusão, Autodesk Tinkercad Circuito é uma poderosa ferramenta online

para projetar e simular circuitos eletrônicos. Ele fornece uma interface amigável, uma
biblioteca de componentes eletrônicos e um recurso de simulação que permite aos
usuários testar seu circuito antes de construí-lo no mundo real. Com seu editor de
código integrado e suporte para várias linguagens de programação.
COMO FUNCIONA A PLATAFORMA ONLINE DO TINKERCAD?

A apostila irá focar exclusivamente na criação e montagem de circuitos
eletrônicos. Além de possuir a vantagem de ser uma ferramenta online e gratuita! E
apresenta a vantagem que não há riscos de queimar componentes eletrônicos.
Site: https://www.tinkercad.com/
23
Identificação das partes da ferramenta Tinkercadd do Arduino
Logo de retorno para tela principal do Tinkercad e nome aleatório dado
ao circuito pelo ambiente do Tinkercad.
Mensagens do sistema, vista do circuito, vista esquemática, lista de
componentes e identificação do usuário com foto.
Barra de ferramentas: copiar, colar e excluir. Desfazer e refazer.
Ferramentas de notas e alterar visibilidade de notas. Cor do fio e tipo de
fio. Rotacionar e espelhar componente.
Alternar editor de código: bloco, bloco e texto, texto. Iniciar simulação e
parar simulação. Enviar para.
Zoom para ajustar.
Localizar mais componentes. Alterar para vista com detalhes.
Procurar componentes.
24
Lista de componentes.
Área de trabalho do Tinkercad.
25
Aula 01 - Hello, World!
O QUE VAMOS FAZER?
Fazer piscar um LED com o Arduino.
PEÇAS QUE SERÃO UTILIZADAS

Para fazer este projeto, serão necessários os seguintes componentes:
Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
3 Resistor de 100 ohms 01
4 LED vermelho 01
5 Cabo jumper macho curto 01
6 Cabo jumper macho longo 01
PASSOS DA MONTAGEM DA PROTOBOARD

Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a conexão
correta dos componentes.
Passo 1 - Conecte a perna positiva (grande) do LED na casa 6e e a negativa (pequena)
na casa 5e.
Passo 2 – Conecte o resistor na casa 5b e nos pinos negativos da protoboard.
26
Passo 3 – Conecte o fio verde na casa 6b da protoboard e no pino digital 8 da placa do
Arduino e conecte o fio preto no ponto negativo da protoboard e no pino GND da placa
do Arduino.
SCRIPT ARDUINO
Segue abaixo o código fonte deste projeto. Copie e cole na IDE do Arduino.
1 /*
2 Projeto acendendo um LED.
3 */
4
5 void setup()
6 {
7 pinMode(8, OUTPUT);
8 }
9
10 void loop()
11 {
12 digitalWrite(8, HIGH);
13 delay(1000);
14 digitalWrite(8, LOW);
15 delay(1000);
16 }
RESULTADO
Após o envio do programa, o LED ficará aceso até o Arduino ser desligado.
COMENTÁRIOS
27
Aula 02 - LED com botão liga desliga
CRÉDITOS DA AULA
O QUE VAMOS FAZER?

Como acender um LED com botão no Arduino.
Este projeto consiste em controlar o funcionamento de um LED, ligando e desligando-
o por meio de um push button.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
7 LED vermelho 01
8 Push button 01
28
Passo 1 - Conecte o botão na protoboard, atentando para a sua posição, que pode ser vista na
imagem abaixo.
Neste caso conectamos uma perna do botão na coluna 50 e uma na coluna 48 da protoboard.
29
Passo 2 – Agora, conecte uma perna do resistor de 150 ohms na coluna 48, a mesma do botão, e
a outra perna do resistor você vai conectar na coluna 45. Conecte um fio jumper ligando a perna do
resistor na coluna 45 (fio preto) a linha horizontal negativa (linha azul da protoboard). Conecte outro
fio jumper ligando a perna do botão da coluna 50 (fio vermelho) a linha horizontal positiva (linha
vermelha da protoboard).
Passo 3 - Conecte um fio jumper, fio amarelo, entre a perna do botão e a do resistor na coluna 48.
30
Passo 4 - Agora chegou a hora de ligar o LED na protoboard. Conecte a perna grande do LED na
coluna 55 e a perna pequena na coluna 56. Conecte um resistor de 100 ohms entre o LED e o fio
jumper, conforme mostra a imagem abaixo.
Passo 5 - Conecte um fio jumper na coluna 56 e na linha negativa da protoboard, ligando a perna
pequena do LED com a linha negativa.
Passo 6 - Conecte um fio jumper no início da linha negativa, fio preto, e outro no início da linha
positiva, o fio vermelho.
Passo 7 - Conecte a protoboard, juntamente com os seus componentes (LED, botão, resistores) no
Arduino. Para facilitar o entendimento e a explicação usarei como referência as cores dos fios
jumper usados neste projeto. Segue abaixo os passos para realizar as ligações dos fios jumper da
protoboard ao Arduino.
• fio amarelo ao pino digital 2 do Arduino;

• fio azul ao pino digital 8 do Arduino;
• fio vermelho ao pino de alimentação 5V;
• fio preto ao pino GND.
Feito isso seu projeto físico Arduino LED com botão está completo e pronto para funcionar.
SCRIPT ARDUINO
31
Segue abaixo o código fonte do programa que vai controlar o Arduino, conforme o presionamento
do botão, que se estiver apertado acende o LED, se não apaga o LED.
Neste projeto é introduzido o uso de constantes em programas Arduino. A diferença de uma
constante para uma variável é que uma variável pode ter seu valor alterado quantas vezes for
necessário dentro do programa. Já a constante, uma vez que se define o valor inicial não se pode
mais alterar este valor.
Neste programa também é utilizado o comando digitalRead que, neste caso, faz a leitura do pino
digital 2, detectando se o mesmo está ou não recebendo energia.
Em síntese, este programa captura o estado do botão, pressionado ou não pressionado, e, de
acordo com o estado, envia ou não energia para acender o LED.
1 /*
2 Projeto Arduino acendendo e apagando o LED com botão.
3 Por João Paulo - Jota
4 ----------------------------------------
5 --=<| www.ComoFazerAsCoisas.com.br |>=--
6 ----------------------------------------
7 */
8
9 //Declaração das constantes
10 const int led = 8; //constante LED refere-se ao pino digital 8.
11 const int botao = 2; //constante botão refere-se ao pino digital 2.
12
13 //Variável que conterá os estados do botão (0 LOW, 1 HIGH).
14 int estadoBotao = 0;
15
16 //Método setup, executado uma vez ao ligar o Arduino.
17 void setup() {
18 pinMode(led,OUTPUT); //Definindo pino digital 8 como de saída.
19 pinMode(botao,INPUT); //Definindo pino digital 2 como de entrada.
20 }
21
22 //Método loop, executado enquanto o Arduino estiver ligado.
23 void loop() {
24 //Lendo o estado do pino 2, constante botao, e atribuindo
25 //o resultado a variável estadoBotao.
26 estadoBotao = digitalRead(botao);
27
28 //Verificando o estado do botão para definir se acenderá ou
29 //apagará o LED.
30 if (estadoBotao == HIGH) {
31 digitalWrite(led,HIGH); //Botão pressionado, acende o LED.
32 } else {
33 digitalWrite(led,LOW); //Botão não pressionado, apaga o LED.
34 }
35 }
Com o programa na IDE do Arduino, agora é só compilar e depois fazer o upload. A imagem abaixo
destaca os botões de verificação/compilação e de upload na barra de ferramentas da IDE do
Arduino.
32
Após a compilação e upload seu projeto está completamente pronto! Agora é só apertar o botão
para acender o LED.
RESULTADO
COMENTÁRIOS
33
Aula 03 - Controlar um LED com um potenciômetro
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-como-controlar-um-led-com-
potenciometro.html
O QUE VAMOS FAZER?
Acender e pagar um LED utilizando um potenciômetro para controlar o tempo de pausa entre um
estado e outro.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
5 Resitor3 de 100 ohms 01
6 LED azul 01
7 Potenciômetro4 de 10k 01
3 Os resistores são componentes eletrônicos passivos, muito comuns no mundo da eletrônica e a letra R
é usada para representá-lo. Os resistores não são polarizados, ou seja, não possuem polo positivo e
negativo. A função do resistor é limitar o fluxo de corrente elétrica que passa por ele, e a essa limitação
se dá o nome de resistência, medida em ohms, e ela define qual a facilidade ou dificuldade que os
eletrons terão que enfrentar para passar pelo resistor. Quanto maior o valor da resistência (em ohms)
mais difícil será para os eletrons passarem pelo resistor e quanto menor o valor da resistência (em ohms)
mais fácil será para os eletrons passarem. A limitação do fluxo da corrente elétrica que o resistor impõe
causa também uma queda na tensão.
4 Potenciômeto é um componente eletrônico que cria uma limitação para o fluxo de corrente elétrica que
passa por ele, e essa limitação pode ser ajustada manualmente, podendo ser aumentada ou diminuida.
Os potenciômetros e o resistores tem essa finalidade de limitar o fluxo de corrente elétrica em um circuito,
a diferença é que o potenciômetro pode ter sua resistência ajustada e o resistor comum não pode pois
ele possui um valor de resistência fixo.
34
O primeiro passo é conectar o LED, o potenciômetro e o resistor na protoboard. Neste caso o LED
teve a sua perna maior conectada na coluna 55 e a menor conectada na coluna 56. O resistor de
100 ohms apenas uma de suas pernas conectada na coluna 55 e o potenciômetro teve uma perna
conectada na coluna 40, outra na 42 e outra na 44. Veja a disposição dos componentes na imagem
abaixo.
Usando os fios jumper pequenos conecte uma perna do LED, a da coluna 56, na linha horizontal
azul, que será o fio terra do projeto. Conecte a perna da coluna 40 do potenciômetro também na
linha horizontal azul e a perna da coluna 44 na linha horizontal vermelha, que fornecerá os 5V do
projeto.
35
Conecte os fios jumper médios na protoboard, um na coluna 42 que é a perna do meio do
potenciômetro, no caso do fio azul conecte-o direto na perna do resistor, não é necessário conectar
nem esta perna do resistor nem o fio azul na protoboard, a ligação é direta entre o fio azul e uma
perna do resistor. Um fio na linha horizontal vermelha (5V) e um na linha horizontal azul (terra).
36
Abaixo está melhor exemplificado a ligação entre LED, resistor e fio jumper.
Agora chegou a hora de conectar os fios da protoboard no arduino, usarei as cores dos fios usadas
neste projeto como referência para explanar esta ligação.
A conexão será feita da seguinte forma:
• fio azul (resistor e LED) no pino digital 8;

• fio verde (perna central do potenciômetro) no pino analógico A2;
• fio preto no pino GND;
• fio vermelho no pino 5V.
O potenciômetro foi ligado ao pino analógico pelo fato deste pino poder assumir valores
diversos e não apenas 0 e 1 que é o caso do pino digital.
37
SCRIPT ARDUINO
Após fazer as ligações entre o arduino e a protoboard o seu projeto físico está pronto, faltando agora
a programação que irá controlar o arduino nesta tarefa de piscar o LED em intervalos definidos via
potenciômetro. Para programar o arduino conecte-o no seu computador usando um cabo USB e
execute a IDE.
Segue abaixo o código fonte deste projeto, que é bem simples e fácil de entender. Copie e cole na
IDE do Arduino.
1 /*
2 Pisca um LED, onde a velocidade das piscadas é
3 controlada por um potenciômetro.
4 Por Jota
5 ----------------------------------------
7 ----------------------------------------
8 */
9
10 int ledAzul = 8;
11 int potenciometro = 2;
12 int tempoDeEspera = 0;
13
14 void setup() {
15 pinMode(ledAzul,OUTPUT);
16 }
17
18 void loop() {
19 //Leitura do valor do potenciômetro que é usada como delay
20 tempoDeEspera = analogRead(potenciometro);
21
22 digitalWrite(ledAzul, HIGH);
23 delay(tempoDeEspera);
24 digitalWrite(ledAzul, LOW);
25 delay(tempoDeEspera);
26 }
Em resumo este código fonte define que o tempo de espera entre as piscadas do LED será lido do
protenciômetro pelo pino analógico A2 e será aplicado utilizando o comando delay. Após copiar o
código fonte do projeto para a IDE do arduino compile e posteriormente faça o upload.
38
RESULTADO
COMENTÁRIOS
39
Aula 04 - Botão que acende LED-s com efeito
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-botao-acende-leds-com-efeito.html
O QUE VAMOS FAZER?

Acender LED-s com efeito utilizando um botão.
Acender vários LED-s ao se pressionar um botão. Neste projeto um pequeno efeito é gerado, pois
foi definido um intervalo de tempo entre o acendimento de cada LED. Este projeto reforça o projeto
LED com botão liga desliga que também usa um botão para acender um LED e que tem uma
programação mais simples.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
7 LED azul 01
8 LED vermelho 01
9 LED verde 01
10 LED amarelo 01
12 Push button 01
40
A primeira coisa a fazer é colocar os LED-s e o botão na protoboard. Neste caso as pernas grandes
dos LED-s foram conectadas nas colunas 40, 45, 50, 55. As pernas pequenas dos LED-s foram
conectadas nas colunas 41, 46, 51, 56. O botão teve suas perninhas conectadas as colunas 33 e
35.
41
Agora chegou a vez dos resistores. Conecte os quatros resistores de 100 ohms nas colunas que
estão conectadas as pernas grandes dos LED-s (colunas 40, 45, 50 e 55) conforme mostra a
imagem abaixo. Os resistores dos LED-s devem ter apenas uma de suas pernas conectadas a
protoboard, pois a outra perna do resistor será ligada aos fios jumper que serão conectados ao
Arduino. Conecte o resistor de 150 ohms na coluna 33 e na linha horizontal negativa da protoboard
(linha azul neste caso) como na imagem abaixo.
Conecte os fios jumper pequenos na linha horizontal negativa da protoboard e nas colunas das
pernas pequenas dos LED-s, no caso as colunas 41, 46, 51, 56. Conecte a coluna 35, que esta a
perninha do botão um fio jumper ligado a linha horizontal positiva da protoboard, linha vermelha
neste caso.
Chegou a hora de conectar os fios jumper maiores na protoboard. Para cada perna grande de um
LED vai ligar um fio jumper, neste caso o fio azul esta ligado no resistor da coluna 55, o fio vermelho
no resistor da coluna 50, o fio verde no resistor da coluna 45 e o fio amarelo no resistor da coluna
40. Na coluna 33 entre o botão e o resistor você vai ligar outro fio jumper, neste caso é o fio jumper
roxo. Para finalizar conecte um fio jumper na linha horizontal negativa azul, neste caso foi o fio preto,
e outro fio na linha horizontal positiva vermelha, neste caso foi o fio cinza.
42
Veja na imagem abaixo outro ponto de vista da protoboard com todos os componentes do projeto
arduino com um botão que acende os LED-s com efeito. O próximo passo é conectar os fios jumper
grandes no arduino.
Abaixo está melhor exemplificado como deve ser feita a ligação entre cada um dos LED-s, resistores
e fios jumper.
Os fios jumpers grandes serão conectados da seguinte forma:
• fio azul no pino digital 11;

• fio vermelho no pino digital 10;
• fio verde no pino digital 9;
• fio amarelo no pino digital 8;
• fio roxo no pino digital 2;
• fio preto no pino GND;
• fio cinza no pino 5V.
Os pinos digitais 8, 9, 10, e 11 do arduino serão responsáveis por enviar a energia para acender os
LED-s conectados na protoboard. O pino digital 2 será um pino de entrada, que receberá ou não
energia, conforme o presionamento do botão, possibilitando a leitura do estado do botão
43
(pressionado ou não pressionado). O pino GND é o terra do arduino, onde estão conectadas todas
as perninhas menores dos LED-s. E o pino 5V é o responsável por mandar energia para o botão
possibilitando o controle do seu estado, juntamente com o pino digital 2 do arduino.
44
SCRIPT ARDUINO
Segue abaixo o código fonte completo e testado deste projeto. Copie e cole ou faça você mesmo a
sua versão do programa de controle do Arduino, compile, e posteriormente faça o upload do
programa para o Arduino.
1 /*
2 Projeto Arduino acendendo com efeito e apagando os LED-s com botão.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 //Declaração das constantes referentes aos pinos digitais.
10 const int ledAmarelo = 8;
11 const int ledVerde = 9;
12 const int ledVermelho = 10;
13 const int ledAzul = 11;
14 const int botao = 2;
15
16 //Declaração da variável que possuirá os estados do botão.
17 int estadoBotao = 0;
18
19 //Método setup, executado uma vez assim que o Arduino é ligado.
20 void setup() {
21 pinMode(ledAmarelo,OUTPUT); //Definindo pino 8 como saída.
22 pinMode(ledVerde,OUTPUT); //Definindo pino 9 como saída.
23 pinMode(ledVermelho,OUTPUT); //Definindo pino 10 como saída.
24 pinMode(ledAzul,OUTPUT); //Definindo pino 11 como saída.
25
26 pinMode(botao,INPUT); //Definindo pino 2 como entrada.
27 }
28
30 void loop() {
31 estadoBotao = digitalRead(botao);
32
33 if (estadoBotao == HIGH) {
45
34 //Acendendo os LED-s caso o botão esteja pressionado, com
35 //um intervalo de tempo (delay) entre os acendimentos para
36 //criar um pequeno efeito.
37 digitalWrite(ledAmarelo,HIGH);
38 delay(200);
39 digitalWrite(ledVerde,HIGH);
40 delay(200);
41 digitalWrite(ledVermelho,HIGH);
42 delay(200);
43 digitalWrite(ledAzul,HIGH);
44 delay(200);
45 } else {
46 //Apagando os LED-s caso o botão não esteja pressionado.
47 digitalWrite(ledAmarelo,LOW);
48 digitalWrite(ledVerde,LOW);
49 digitalWrite(ledVermelho,LOW);
50 digitalWrite(ledAzul,LOW);
51 }
52 }
RESULTADO
Em resumo, este programa verifica se o botão está pressionado, e caso esteja acende os LED-s.
Caso não esteja pressionado apaga os LED-s.
COMENTÁRIOS
46
Aula 05 - Controlando 8 LED-s com CI74HC595 e fazendo contagem
binária
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/controlando-8-leds-com-arduino-usando-ci74HC595-
fazendo-uma-contagem-binaria.html
O QUE VAMOS FAZER?
Fazer um contador binário que usa 8 LED-s para formar um byte, onde um LED aceso representa
1 e o LED apagado representa 0, e esse conjunto de 8 LED-s que forma o byte irá representar um
número entre 0 e 255, ou melhor, irá contar de 0 até 255 só que em base binária. O componente
principal desse projeto é o circuito integrado 74HC595, que vai ser responsável pelo controle dos 8
LED-s.
O circuito integrado 74HC595 tem a capacidade de transformar uma entrada serial em uma saída
paralela de 8 vias, e cada uma dessas 8 vias da saída paralela irá controlar um LED. E o melhor é
que para controlar esses 8 LED-s vamos usar apenas 3 pinos do Arduino.
Neste projeto os números decimais entre 0 e 255 vão ser representados de forma binária. Para
entender melhor, segue abaixo uma tabela de equivalência entre binários e decimais.
00000001 (binário) é igual a 1 (decimal);
11111111 (binário) é igual a 255 (decimal).
Lembro que um LED aceso é igual a 1 e um led apagado é igual a 0.
Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
5 Resistor de 1k ohms 08
6 LED azul 08
Registrador de deslocamento de
7 01
oito bits 74HC595
47
Numa visão geral este projeto funcionará da seguinte forma, o arduino avisa ao CI74HC595 que
vai enviar dados, o CI se prepara para receber os bits, então o arduino envia 8 bits, um de cada
vez, ou seja sequencialmente, o CI apenas armazena cada um dos 8 bits enviados, o arduino
envia um sinal ao CI para que ele libere os 8 bits armazenados, e o CI libera os 8 bits de uma vez,
ou seja paralelamente. E esses passos se repetem para a formação de cada um dos números
entre 0 e 255.
O CI74HC595 é muito bom para controlar muitos LED-s usando poucos pinos do arduino. O
projeto do contador binário apresentado neste post é apenas um exemplo entre milhares de
projetos de controle de LED-s que podem ser desenvolvidos com o CI74HC595.
Segue abaixo o datasheet do CI74HC595, para que você conheça cada um dos pinos do mesmo.
Bem, para começar vamos conectar na protoboard os componentes do projeto, que são os oito
LED-s, de 5mm neste caso, o CI74HC595, e os oito resistores de 330 ohms, um em cada perna
positiva dos LED-s.
48
Agora conecte os fios jumper entre os componentes da protoboard e entre a protoboard e o
Arduino. O esquema detalhado da ligação dos fios jumpers entre os componentes e o Arduino
está detalhado logo abaixo.
• pino 1 do 74HC595 ligado ao positivo do 2º LED;

• pino 8 do 74HC595 ligado ao GND do Arduino;
• pino 9 do 74HC595 sem ligação;
• pino 10 do 74HC595 ligado ao 5V do Arduino;
• pino 11 do 74HC595 ligado ao pino digital 2 do Arduino;
• pino 13 do 74HC595 ligado ao GND do Arduino;
• pino 16 do 74HC595 ligado ao 5V do Arduino.
SCRIPT ARDUINO
49
Depois de concluir o projeto físico, ou seja, a montagem e as conexões entre Arduino e
componentes, chegou a hora de programar o Arduino para que ele faça o que queremos. Então
usando o cabo USB conecte o Arduino ao seu computador e execute a IDE do Arduino.
1 /*
2 Projeto Arduino contador binário
3 com saída em 8 LED-s que formam 1 byte.
4 Por Jota
5 ----------------------------------------
7 ----------------------------------------
8 */
9
10 //Constantes associadas aos pinos do Arduino
11 int const clock = 2; //ligado ao clock do 74HC595
12 int const latch = 3; //ligado ao latch do 74HC595
13 int const data = 4; //ligado ao data do 74HC595
14
15 void setup() {
16 //definindo os pinos como de saída
17 pinMode(clock,OUTPUT);
18 pinMode(latch,OUTPUT);
19 pinMode(data,OUTPUT);
20 }
21
22 void loop() {
23 //Contando de 0 até 255
24 for (int i = 0; i <= 255; i++) {
25
26 //permite o fluxo dos dados.
27 digitalWrite(latch,LOW);
28
29 for (int x = 0; x <= 7; x++) {
30
31 //pronto para receber o bit.
32 digitalWrite(clock,LOW);
33
34 if (i & (1 << x)) {
35 digitalWrite(data,HIGH);
36 } else {
37 digitalWrite(data,LOW);
38 }
39
40 //grava o bit recebido.
41 digitalWrite(clock,HIGH);
42 }
43
44 //finaliza o fluxo dos dados e envia os 8 bits.
45 digitalWrite(latch,HIGH);
46
47 //tempo de espera entre a exibição de um
48 //número e o outro.
49 delay(100);
50 }
51 }
RESULTADO
50
Após introduzir o código fonte deste projeto na IDE do Arduino, compile-o e posteriormente faça o
upload.
Aguarde alguns segundos e logo o seu projeto estará em funcionamento, contando de 0 até 255 em
base binária, e além disso o efeito dos LED-s apagando e acendendo durante a contagem é muito
legal.
COMENTÁRIOS
51
Aula 06 - Piscar um LED com efeito fader
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-como-piscar-led-com-efeito-fader.html
O QUE VAMOS FAZER?
Piscar um LED com efeito fader.
Diferente do acendimento normal que acende e apaga de uma vez o LED, o efeito fader faz com
que o LED vá acendendo progressivamente, de uma luizinha bem fraca para uma luz forte, e depois
apague da mesma forma.
O segredo deste projeto está na programação e no uso de um pino digital PWM que pode funcionar
como um pino analógico. PWM (Pulse-Width Modulation) ou modulação por largura de pulso é um
meio para se obter resultados analógicos em um pino digital.
Alguns pinos digitais do Arduino possuem esse recurso, no caso do Arduino UNO R3 os pinos
digitais 3, 5, 6, 9, 10 e 11 são PWM. Impresso na placa Arduino existe uma indicação de quais pinos
são PWM. Veja abaixo que os pinos PWM possuem um til ( ~ ) antes do número do pino.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
3 LED azul 01
52
O primeiro passo é conectar o LED e o resistor na protoboard. O resistor deve estar ligado a perna
positiva do LED.
Conecte o fio azul na perna positiva do led, antes do resistor, e conecte o fio preto na perna negativa
do LED. Veja no exemplo abaixo.
No arduino conecte o fio azul no pino digital 10. Observe que o pino digital 10 é um pino PWM, que
pode funcionar como um pino analógico. Conecte o fio preto no pino GND.
Logo abaixo está o esquema do projeto pisca LED com efeito fader.
53
SCRIPT ARDUINO
Segue abaixo o código fonte completo que pisca um LED com efeito fader. Lembrando que como
estamos usando um pino digital, no caso o pino 10, que possui recurso PWM vamos tratá-lo como
analógico, usando o comando analogWrite (LED, brilho).
O intervalo/escala de valores para o pino PWM é de 0 até 255, por isso a variável brilho irá assumirá
valores entre 0 e 255 durante a execução do programa. E quanto menor for o valor da variável brilho
menor será o brilho do LED, e quanto maior for o valor da variável brilho maior será o brilho do LED.
Quando brilho for igual a zero o LED será apagado. Quando brilho for igual a 255 o LED brilhará no
máximo.
1 /*
2 Projeto Arduino acendendo led com efeito fader.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 //Constante que representa o pino onde o positivo do
10 //led será ligado.
11 const int led = 10;
12
13 //Controladores do efeito de fader
14 int brilho = 0;
15 int fader = 5;
16 boolean acende = true;
17 boolean apaga = false;
54
18
20 void setup() {
21 //Definindo o pino led como de saída.
22 pinMode(led,OUTPUT);
23 }
24
26 void loop() {
27 analogWrite(led,brilho);
28
29 //Processo de acendimento do led usando o efeito fader.
30 if (acende == true) {
31 if (brilho < 255) {
32 brilho = brilho + fader; //aumentando o brilho do led.
33 } else {
34 acende = false;
35 apaga = true;
36 }
37 }
38
39 //Processo para apagar o led com efeito fader.
40 if (apaga == true) {
41 if (brilho > 0) {
42 brilho = brilho - fader; // diminuindo o brilho do led.
43 } else {
44 acende = true;
45 apaga = false;
46 }
47 }
48
49 delay(20);
50 }
RESULTADO
Compile o programa na IDE do arduino e depois faça o upload e o seu projeto arduino de piscar um
LED com efeito fader está concluído.
COMENTÁRIOS
55
Aula 07 - Sinal de trânsito
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-sinal-de-transito.html
O QUE VAMOS FAZER?

Montar um sinal de trânsito.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
3 LED vermelho 01
4 LED amarelo 01
5 LED verde 01
56
O primeiro passo é conectar os LED-s na protoboard. Neste caso o LED vermelho foi conectado na
coluna 5 (perna menor) e na coluna 6 (perna maior), o LED amarelo foi conectado na coluna 10
(perna menor) e na coluna 11 (perna maior) e o LED verde foi conectado na coluna 15 (perna menor)
e na coluna 16 (perna maior).
Conectar a perna de cada um dos resistores de 100 ohms nas colunas 5, 10, e 15 e a outra perna
na linha azul (negativo) da sua protoboard.
Conecte os fios jumper nas colunas 6, 11 e 16 da protoboard.
57
Usando as cores dos fios jumper da imagem abaixo, conecte o fio jumper preto no pino digital GND
do Arduino. Conecte o fio amarelo no pino digital 10 do arduino, o laranjado no pino digital 9 do
Arduino e o vermelho no pino digital 8 do Arduino.
SCRIPT ARDUINO
58
Conecte o seu Arduino ao computador usando o cabo USB. Abra a IDE do Arduino, copie e cole na
IDE o código fonte do programa.
1 //Projeto Arduino sinal de trânsito
2 //Por Jota
3 //www.comofazerascoisas.com.br
4
5 //Método setup, assim que o arduino é ligado ele
6 //é executado, uma vez apenas.
7 void setup() {
8 pinMode(8,OUTPUT); //define o pino 8 como saída
11 }
12 //Método loop, é executado enquanto o arduino estiver ligado.
13 void loop() {
14 //Controle do LED verde
15 digitalWrite(8,HIGH); //acende o LED
16 delay(4000); //espera 4 segundos
17 digitalWrite(8,LOW); //apaga o led
18
19 //Controle do LED amarelo
23
24 //Controle do LED vermelho
28 }
Agora compile o programa, pressionando o botão Verify (botão com um V) e posteriormente faça o
upload do programa para o Arduino pressionando o botão Upload (botão com uma seta apontando
para a direita).
59
RESULTADO
Após o upload do programa para o Arduino, o mesmo já começa a se comportar como um sinal de
trânsito, acendento e apagando os LED-s de acordo com a ordem e o tempo definido no programa.
COMENTÁRIOS
60
Aula 08 - Dois sinais de trânsito sincronizados
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/arduino-uno-projeto-sinais-de-transito-sincronizados.html
O QUE VAMOS FAZER?

Montar dois sinais de trânsito sincronizados.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
3 LED vermelho 02
4 LED amarelo 02
5 LED verde 02
61
Como fazer dois sinais de trânsito sincronizados. Este tipo de sinal controla o fluxo dos veículos em
duas pistas distintas que se encontram, muito comum em qualquer cidade. E também você
aprenderá alguns aspectos mais interessantes sobre a programação e o projeto físico do Arduino.
Quando duas pistas se encontram existe a necessidade de controlar o fluxo de veículos entre elas,
para evitar colisões. Neste caso existe a necessidade de dois sinais de trânsito sincronizados para
controlar este fluxo de veículos. Este sincronismo entre os sinais significa que enquanto um estiver
aberto, luz verde, ou em estado de atenção, luz amarela, o outro deve estar fechado e vice versa.
Neste projeto vamos contruir um protótipo que faz esse exatamente este controle, simulando dois
sinais de trânsito sincronizados.
62
A primeira coisa a se fazer é conectar os LED-s na protoboard. Cada grupo de três LED-s (verde,
amarelo e vermelho) vai representar um sinal de trânsito. As perninhas menores dos LED-s foram
conectadas nas colunas 5, 10, 15, 20, 25, 30. As pernas maiores nas colunas 6, 11, 16, 21, 26, 31.
Agora você deve dobrar as perninhas dos resistores de 100 ohms para conectá-los a protoboard.
Se você tiver um alicate de bico use-o para fazer as dobras.
63
Conecte os resistores na protoboard, onde uma ponta do resistor ficará ligada na mesma coluna da
perna pequena do LED e a outra ponta na linha negativa (linha horizontal azul neste caso). Logo os
resistores serão conectados nas colunas 5, 10, 15, 20, 25, 30 e na linha negativa (linha horizontal
azul neste caso).
Conecte agora os fios jumpers nas mesmas colunas das pernas maiores dos LED-s e um fio jumper
na linha negativa (linha horizontal azul neste caso). Logo os fios jumpers ficarão nas colunas 6, 11,
16, 21, 26, 31 e um fio jumper na linha negativa.
64
Conecte os fios jumpers nos pinos digitais do Arduino UNO da seguinte forma:
Fio jumper da linha negativa (azul) no pino GND.
Consideraremos o primeiro sinal o conjunto de três LED-s da direita, e o segundo sinal o conjunto
de três LED-s da esquerda.
Primeiro sinal
LED vermelho no pino 5;
LED amarelo no pino 6;
LED verde no pino 7.
Segundo sinal
LED vermelho no pino 8;
LED amarelo no pino 9;
LED verde no pino 10;
65
Para começar a programação conecte o Arduino ao seu computador pelo cabo USB, e no
computador execute a IDE do Arduino.
66
67
SCRIPT ARDUINO
Copie o código fonte abaixo e cole na IDE do Arduino. Este código fonte faz o controle dos dois
sinais de trânsito para que eles funcionem de forma sincronizada, como um sinal de trânsito real.
No método setup os pinos de 5 a 10 foram definidos como pinos de saída.
No método loop cada linha está comentada com a funcionalidade de cada comando.
1 /*
2 Projeto Arduino 2 sinais de trânsito sincronizados
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 //O método setup é executado apenas uma vez,
10 //quando o arduino é ligado
11 void setup() {
12 //definindo os pinos digitais 5, 6, 7, 8, 9 e 10
13 //como pinos de saída.
14 pinMode(5,OUTPUT);
20 }
21
22 //o método loop é executado repetidamente enquanto o
23 //arduino estiver ligado.
24 void loop() {
25 digitalWrite(5,LOW); //apaga o led vermelho (sinal 1)
26 digitalWrite(7,HIGH); //acende o led verde (sinal 1)
27 digitalWrite(8,HIGH); //acende o led vermelho (sinal 2)
29 digitalWrite(7,LOW); //apaga o led verde (sinal 1)
30
31 digitalWrite(6,HIGH); //acende o led amarelo (sinal 1)
33 digitalWrite(6,LOW); //apaga o led amarelo (sinal 1)
34
35 digitalWrite(5,HIGH); //acende o led vermelho (sinal 1)
36 digitalWrite(8,LOW); //apaga o led vermelho (sinal 2)
37 digitalWrite(10,HIGH); //acende o led verde (sinal 2)
39 digitalWrite(10,LOW); //apaga o led verde (sinal 2)
40
41 digitalWrite(9,HIGH); //acende o led amarelo (sinal 2)
43 digitalWrite(9,LOW); //apaga o led amarelo (sinal 2)
44 }
68
RESULTADO
Agora vá no menu Sketch e execute a opção Veriy/Compile (ou pressione as teclas
CTRL + R) para realizar a compilação do seu programa. E, posteriormente, vá ao menu
File e execute a opção Upload (ou pressione as teclas CTRL + U) para fazer o upload
do programa para o Arduino.
Aguarde alguns segundos e seu Arduino vai começar a funcionar igualzinho a dois
sinais de trânsito sincronizados.
COMENTÁRIOS
69
Aula 09 - Controlando LED RGB multicolorido
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-controlando-led-rgb-multicolorido.html
O QUE VAMOS FAZER?

Controlar LED RGB multicolorido.
O LED RGB (Red, Green and Blue) é um tipo de LED, com quatro perninhas, capaz de
emitir diversos tipos de cores. Suas cores básicas são vermelho, verde e azul, e a
mistura dessas cores pode formar diversas outras cores.
No projeto, controlando LED RGB é apresentado uma forma simples e prática de
controlar o LED RGB para emitir suas cores básicas e também para emitir cores
formadas a partir da combinação de outras cores.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
3 LED RGB 01
70
Para facilitar o entendimento segue abaixo o esquema dos LED-s RGB com suas
respectivas pernas e cores.
Vamos começar conectando o LED RGB na protoboard, como mostrado na imagem

abaixo.
• red cathode coluna 29 da protoboard;
• common anode coluna 30 da protoboard;
• green cathode coluna 31 da protoboard;
• blue cathode coluna 32 da protoboard.
71
Conecte apenas uma perna dos três resistores de 330 ohms nas colunas 29, 31 e 32
da protoboard, onde cada resistor ficará ligado a uma perna de cada cor do led.
Conecte agora os fios jumper na protoboard da seguinte forma:

• fio vermelho direto na perna do resistor da coluna 29;
• fio preto na coluna 30;
• fio verde direto na perna do resistor da coluna 31;
• fio azul direto na perna do resistor da coluna 32;
Os fios jumper vermelho, verde e azul estão conectados respectivamente nas pernas
das cores vermelho, verde e azul do led. E lembro que os resistores têm apenas uma
perna ligada na protoboard e a outra ligada direto nos fios.
Outro ponto de vista da ligação dos fios jumper na protoboard.

Agora chegou a hora de conectar os fios jumper no Arduino. Neste projeto iremos
utilizar os pinos digitais e o pino GND. Os pinos digitais serão responsáveis por fornecer
a energia para acendimento de cada cor do LED e o pino GND será o terra do LED.
72
Os fios deverão ser conectados da seguinte forma no arduino:
• fio verde no pino digital 8 do arduino;
• fio azul no pino digital 9 do arduino;
• fio vermelho no pino digital 10 do arduino;
• e fio preto no pino GND.
73
SCRIPT ARDUINO
Primeiramente conecte o Arduino ao seu computador utilizando o cabo USB, execute
a IDE do Arduino e insira o código fonte do projeto, que esta logo abaixo.
1 /*
2 Projeto Arduino controla led RGB.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
10 const int ledAzul = 10;//refere-se ao pino digital 10.
11 const int ledVerde = 9; //refere-se ao pino digital 9.
12 const int ledVermelho = 8; //refere-se ao pino digital 8.
13
15 void setup() {
16 //Definindo os pinos digitais (8, 9, 10) como de saída.
18 pinMode(ledVerde,OUTPUT);
19 pinMode(ledVermelho,OUTPUT);
20 }
21
23 void loop() {
24 //Acendendo cada cor individualmente.
26 delay(500);
28
30 delay(500);
32
34 delay(500);
36
37 //Misturando as cores do led para obter cores diferentes.
41 delay(1500);
45 delay(1500);
49 delay(1500);
53 delay(1500);
54 }
74
Após inserir o código fonte do projeto na IDE do Arduino, compile e faça o upload do
programa.
RESULTADO
COMENTÁRIOS
75
Aula 10 - Controlar as cores de um LED RGB com botões
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/arduino-como-controlar-cores-de-um-led-rgb-com-
botoes.html
O QUE VAMOS FAZER?

Controlar as cores de um LED RGB com botões.
Como comtrolar cada uma das cores de um LED RGB usando botões. Neste projeto
terá a possibilidade de acender separadamente cada cor do LED e também acender
várias cores simultaneamente fazendo uma mistura que cria novas cores tudo isso por
meio dos botões.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
3 LED RGB 01
8 Push button 03
76
Primeiramente conecte o LED RGB na protoboard, que de acordo com o esquema

acima, terá a sua perna azul conectada na coluna 53 da protoboard, a verde na coluna
54, o terra na 55, e a vermelha na 56. Conecte também os três botões, onde o primeiro
será conectado nas colunas 50 e 48, o segundo nas colunas 45 e 43 e o terceiro nas
colunas 40 e 38. Veja a imagem abaixo.
O próximo passo é conectar os resistores na protoboard. No caso do led você irá

conectar em cada perna que representa uma cor um resistor de 330 ohms. E nos botões
você irá conectar três resistores de 150 ohms, um na coluna 48, um na coluna 43 e
outro na coluna 38 e os resistores de 150 ohms também deverão ser conectados na
linha horizontal azul (negativa).
77
Usando os fios jumpers pequenos conecte os botões a linha horizontal vermelha
(positivo) nas colunas 50, 45 e 40. Conecte a perna terra do LED, coluna 55, a linha
horizontal azul (negativo).
Agora conecte os demais fios jumpers na protoboard da seguinte forma:

• coluna 38 um fio azul entre o resistor e o botão;
• coluna 43 um fio verde entre o resistor e o botão;
• coluna 48 um fio vermelho entre o resistor e o botão;
78
• coluna 53 um fio azul após o resistor;
• coluna 54 um fio verde após o resistor;
• coluna 56 um fio vermelho após o resistor;
• um fio vermelho na linha vermelha (positivo)
• um fio preto na linha azul (negativo).
A ligação entre o LED, os 3 resistores e os fios jumpers vermelho, verde e azul seria
como mostrado na imagem abaixo.
Conecte os fios da protoboard no Arduino da seguinte forma:
• pino digital 2 fio azul do botão;

• pino digital 3 fio verde do botão;
• pino digital 4 fio vermelho do botão;
• pino digital 8 fio azul do led, fio ligado direto no resistor;
• pino digital 9 fio verde do led, fio ligado direto no resistor;
79
• pino digital 10 fio vermelho do led, fio ligado direto no resistor;
• pino 5V fio vermelho (positivo);
• pino GND fio preto (negativo).
A perna do resistor do led que vai ligada ao fio dos pinos digitais não é conectada na
coluna da protoboard e sim conectada direto no fio.
Após conectar todos os fios, seu projeto físico para controlar as cores de um led RGB
pelos botões está pronto. Agora o próximo passo é conectar o Arduino ao seu
computador por meio do cabo USB para iniciar a programação das funcionalidades
desejadas.
80
SCRIPT ARDUINO
1 /*
2 Projeto Arduino controla LED RGB com botões.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
10 const int ledAzul = 8; //ledAzul refere-se ao pino digital 8.
11 const int ledVerde = 9; //ledVerde refere-se ao pino digital 9.
12 const int ledVermelho = 10; //ledVermelho refere-se ao pino digital 10.
13
14 const int botaoAzul = 2; //botaoAzul refere-se ao pino digital 2.
15 const int botaoVerde = 3; //botaoVerde refere-se ao pino digital 3.
16 const int botaoVermelho = 4; //botaoVermelho refere-se ao pino digital
17 4.
18
19 //Variáveis que conterão os estados dos botões (pressionados ou não).
20 int estadoBotaoAzul;
21 int estadoBotaoVerde;
22 int estadoBotaoVermelho;
23
25 void setup() {
26 //Definindo os pinos digitais (8, 9, 10) como de saída.
81
30
31 //Definindo os pinos digitais (2, 3, 4) como de entrada.
32 pinMode(botaoAzul,INPUT);
33 pinMode(botaoVerde,INPUT);
34 pinMode(botaoVermelho,INPUT);
35 }
36
38 void loop() {
39
40 //Lendo o estado dos botões pelos pinos digitais.
41 estadoBotaoAzul = digitalRead(botaoAzul);
42 estadoBotaoVerde = digitalRead(botaoVerde);
43 estadoBotaoVermelho = digitalRead(botaoVermelho);
44
45 //Acendendo o led RGB conforme os botões pressionados.
46 //Tratando a cor azul
47 if (estadoBotaoAzul == HIGH) {
49 } else {
51 }
52
53 //Tratando a cor verde
54 if (estadoBotaoVerde == HIGH) {
56 } else {
58 }
59
60 //Tratando a cor vermelha
61 if (estadoBotaoVermelho == HIGH) {
63 } else {
65 }
66 }
67
Após inserir o código fonte na IDE do Arduino compile e faça o upload.
RESULTADO
82
Pronto! O projeto como controlar as cores de um LED RGB usando botões está
concluído.
Se você pressionar cada botão individualmente o LED acenderá a respectiva cor.
Se você pressionar mais de um botão de uma vez ocorrerá uma mistura de cores que
formará uma nova cor.
COMENTÁRIOS
83
Aula 11 - Sensor de luz LDR com saída de leitura em LED-s
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-sensor-de-luz-ldr-com-leds.html
O QUE VAMOS FAZER?

Montar um sensor de luz LDR com saída de leitura em LED-s.
Este projeto faz a leitura da iluminação de um ambiente, pelo LDR (Light Dependent
Resistor), e exibe o resultado da leitura do sensor nos LED-s.
Funciona da seguinte forma, caso o ambiente esteja bem iluminado o LED verde
acenderá, caso a iluminação do ambiente for mediana o LED amarelo acenderá e caso
a iluminação esteja ruim o LED vermelho acenderá, e você também poderá ver os
valores lidos no LDR no serial monitor da IDE do Arduino.
Você pode alterar a leitura da iluminação aproximando ou afastando a mão do sensor
LDR.
Os intervalos de valores que representam a intensidade da iluminação são fixos e estão
definidos dentro do programa que se encontra abaixo. Lembro que estes valores podem
ser alterados conforme sua necessidade.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
3 LED vermelho 01
4 LED verde 01
5 LED amarelo 01
Sensor de luz LDR (Light
10 Dependent Resistor), ou seja, 01
fotoresistor
84
Conecte o sensor LDR com uma de suas pernas no 5V do Arduino e a outra perna no
pino analógico A0.
Conecte o resistor de 10K ohms com uma perna entre o sensor LDR e o fio jumper do
pino digital A0 e a outra perna no pino GND.
Conecte os três LED-s na protoboard e na perna maior (positivo) de cada LED conecte
um resistor de 100 ohms e, após o resistor, conecte um fio jumper.
Ligue a perna menor (negativo) de cada um dos LED-s no GND do Arduino.
Os fios positivos dos LED-s ficarão nos seguintes pinos digitais do Arduino:
• fio do LED vermelho no pino digital 10;

• fio do LED amarelo no pino digital 9;
• fio do LED verde no pino digital 8.
85
Veja abaixo as ligações dos fios jumpers no Arduino.
SCRIPT ARDUINO
Abra a IDE do Arduino, conecte ele ao computador pelo cabo USB, insira o código fonte
na IDE compile e faça o upload do programa.
Lembro que os valore lidos no sensor LDR poderão ser visualizados no Serial Monitor
da IDE.
Para acessar o Serial Monitor pressione as teclas Ctrl + Shift + M.
1 /*
2 Projeto Arduino sensor de luz com saida de LED-s.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 int sensor = 0; //Pino analógico em que o sensor está conectado.
10 int valorSensor = 0; //Usada para ler o valor do sensor em tempo real.
11
15
16 //Função setup, executado uma vez ao ligar o Arduino.
17 void setup(){
18 //Ativando o serial monitor que exibirá os valores lidos no sensor.
19 Serial.begin(9600);
20
21 //Definindo pinos digitais dos LED-s como de saída.
23 pinMode(ledAmarelo,OUTPUT);
25 }
26
27 //Função loop, executado enquanto o Arduino estiver ligado.
28 void loop(){
29
30 //Lendo o valor do sensor.
31 int valorSensor = analogRead(sensor);
32
86
33 //Valores da luminosidade podem ser alterados conforme necessidade.
34
35 //Luminosidade baixa.
36 if (valorSensor < 300) {
37 apagaLeds();
39 }
40
41 //Luminosidade média.
42 if (valorSensor >= 300 && valorSensor <= 800) {
43 apagaLeds();
45 }
46
47 //Luminosidade alta.
48 if (valorSensor > 800) {
49 apagaLeds();
51 }
52
53 //Exibindo o valor do sensor no serial monitor.
54 Serial.println(valorSensor);
55
56 delay(50);
57 }
58
59 //Função criada para apagar todos os LED-s de uma vez.
60 void apagaLeds() {
64 }
RESULTADO
Segue abaixo o esquema detalhado do projeto Arduino com sensor de luz LDR com
saída de leitura em LED-s.
COMENTÁRIOS
Aula 12 - Emitir sons com o buzzer
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-como-emitir-sons-com-o-buzzer.html
87
O QUE VAMOS FAZER?
Emitir sons em uma determinada frequência e intervalo de tempo usando um buzzer.
O buzzer é um pequeno alto-falante capaz de emitir sons em diversas frequências e é

normalmente é usado em projetos que necessitam de avisos sonoros, relógios com
alarme e até para reproduzir músicas.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
5 Buzzer de 5 volts 01
88
O primeiro passo é conectar os componentes e os fios na protoboard.

Ligue uma perna do resistor na perna positiva do buzzer.
Ligue o fio preto na perna negativa do buzzer e ligue o fio vermelho na outra perna do
resistor. Veja a imagem abaixo.
No Arduino ligue o fio vermelho no pino digital 10 e o fio preto no pino GND.
Projeto físico concluído, provavelmente o seu ficará parecido ou igual ao da imagem

abaixo. Agora chegou a hora de programar o seu Arduino.
Conecte o Arduino ao computador com o cabo USB e execute a IDE do Arduino.
89
SCRIPT ARDUINO
Segue abaixo o código fonte do projeto com buzzer que faz o mesmo emitir um som de
1500 hz mum intervalor de meio em meio segundo.
A emissão do som se dá por meio da função tone, onde o segundo parâmetro informa
a frequência do som que quer emitir, que neste caso e 1500.
1 /*
2 Projeto Arduino beep com buzzer.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 //Constante que representa o pino onde o positivo
10 //do buzzer será ligado.
11 const int buzzer = 10;
12
14 void setup() {
15 //Definindo o pino buzzer como de saída.
16 pinMode(buzzer,OUTPUT);
17 }
18
20 void loop() {
21 //Ligando o buzzer com uma frequencia de 1500 hz.
22 tone(buzzer,1500);
23 delay(500);
24
25 //Desligando o buzzer.
26 noTone(buzzer);
27 delay(500);
28 }
90
RESULTADO
Após inserir o código fonte na IDE do Arduino compile o programa e faça o upload.
Pronto o buzzer vai começar a dar um beep nos intervalos de tempo e na frequência
programada.
Se você for bom em frequências sonoras poderá tocar até uma música usando o
Arduino.
E para finalizar segue abaixo o esquema do projeto Arduino com buzzer.
COMENTÁRIOS
91
Aula 13 - Controlando dois servomotores com potenciômetros
CRÉDITOS DA AULA
https://www.tinkercad.com/things/2TBggrERoFG-copy-of-68-arduino-pan-tilt-
joystick/editel?tenant=circuits
O QUE VAMOS FAZER?
Controlar servomotores com potenciômetro.

Controlar o sentido da rotação de dois servomoteres, fazendo com que ele gire conforme a posição
do potenciômetro.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
5 Potenciômetro 02
6 Micro servo 02
92
SCRIPT ARDUINO
1 // www.ProgettiArduino.com
2 // Pan tilt controllato do joystick
3
4 #include <Servo.h>
5
6 int ServoHorizontalPin = 3;
7 int ServoVerticalPin = 4;
8 int HorizontalPotPin = A0;
9 int VerticalPotPin = A1;
10 int ServoH_Min = 0;
11 int ServoH_Max = 180;
12 int ServoV_Min = 0;
13 int ServoV_Max = 180;
14
15 Servo HorizontalServo;
16 Servo VerticalServo;
17
18 int HorizontalPotValue;
19 int HorizontalServoPosition;
20 int VerticalPotValue;
21 int VerticalServoPosition;
22
23 void setup()
24 {
25 HorizontalServo.attach(ServoHorizontalPin);
26 VerticalServo.attach(ServoVerticalPin);
27 }
28
29 void loop()
30 {
31 HorizontalPotValue = analogRead(HorizontalPotPin);
32 VerticalPotValue = analogRead(VerticalPotPin);
33 HorizontalServoPosition = map(HorizontalPotValue, 0, 1023, ServoH_Min
34 , ServoH_Max);
35 VerticalServoPosition = map(VerticalPotValue, 0, 1023, ServoH_Min ,
36 ServoH_Max);
37 HorizontalServo.write(HorizontalServoPosition);
38 VerticalServo.write(VerticalServoPosition);
39 delay(20);
40 }
93
RESULTADO
COMENTÁRIOS
94
Aula 14 - Controlando um servomotor com potenciômetro
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/controlando-um-servomotor-com-potenciometro-no-
arduino.html
O QUE VAMOS FAZER?

Controlar um servomotor com um potenciômetro.
Ao girar o potenciômetro o braço do servomotor responderá fazendo um movimento

proporcional a velocidade e ao sentido do giro do potenciômetro. O Arduino usado neste
projeto foi um Arduino UNO R3, mas qualquer outra versão poderia ser utilizada.
O servomotores são componentes muito importantes no mundo da robótica, da
mecatrônica, e muito usado também no mundo dos hobbys. Na robótica os
servomotores são responsáveis por movimentar braços, pernas e mãos de robôs. No
automodelismo os servomotores são usados para virar as rodinhas dianteiras dos
carrinhos, para esquerda e direita. No aeromodelismo são usados para controlar os
flaps das asas dos aviões.
Os servomotores são componentes chave em muitos projetos, por isso vamos ensinar
o conceito básico de controle de um servomotor, usando um Arduino.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
5 Potenciômetro 01
6 Micro servomotor 01
O servomotor usado neste projeto foi um TG9e da Turnigy, um microservo que possui
um ótimo custo-benefício.
Começe conectando o potenciômetro na protoboard e depois conecte os fios jumper
entre os componentes da protoboard, o servomotor e o Arduino.
Para fazer estas conexões corretamente veja o esquema do projeto.
95
SCRIPT ARDUINO
Agora vamos programar o Arduino para que ele se comporte como desejamos. Então
conecte o Arduino ao seu computador com o cabo USB, abra a IDE do Arduino e
programe o Arduino.
Segue abaixo o código fonte deste projeto todo comentado para facilitar o entendimento
de cada parte do código.
1 /*
2 Projeto Arduino controlando um servomotor com potenciômetro
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 //incluindo biblioteca para controle do servomotor
10 #include "Servo.h"
11
12 //Criando um objeto da classe Servo
13 Servo servoMotorObj;
14
15 //pino analógico onde o potenciômetro está conectado
16 int const potenciometroPin = 0;
17
18 //pino digital associado ao controle do servomotor
19 int const servoMotorPin = 3;
20
21 //variável usada para armazenar o valor lido no potenciômetro
22 int valPotenciometro;
23
96
24 void setup() {
25 //associando o pino digital ao objeto da classe Servo
26 servoMotorObj.attach(servoMotorPin);
27 }
28
29 void loop()
30 {
31 //lendo o valor do potenciômetro (intervalo entre 0 e 1023)
32 valPotenciometro = analogRead(potenciometroPin);
33
34 //mapeando o valor para a escala do servo (entre 0 e 180)
35 valPotenciometro = map(valPotenciometro, 0, 1023, 0, 180);
36
37 //definindo o valor/posição do servomotor
38 servoMotorObj.write(valPotenciometro);
39 delay(15);
40 }
RESULTADO
Após introduzir o código fonte na IDE do Arduino, compile-o e depois faça o upload,
aguarde alguns instantes para que a transferência do programa seja realizada.
Vire o potenciômetro para um lado e veja que o braço do servomotor vai se mover.
COMENTÁRIOS
97
Aula 15 - Controlar a velocidade de um motor CC com potenciômetro
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/controlando-a-velocidade-de-um-motor-cc-no-arduino-com-
potenciometro.html
O QUE VAMOS FAZER?

Controlar a velocidade de um motor CC com potenciômetro.
Motor CC, ou corrente contínua, terá a sua velocidade controlada por um potenciômetro
giratório. A medida que gira potenciômetro para o lado esquerdo o motor CC vai
aumentando progressivamente a velocidade e quando você gira para a direita vai
diminuindo a velocidade até parar.
Este projeto é um excelente exemplo de manipulação de um motor CC e o primeiro
passo para quem deseja trabalhar com projetos Arduino voltados para a robótica, pois
motores CC, motores de passo e servo motores são peças-chave na construção de
robos, carrinhos robóticos, braços robóticos etc.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
4 Potenciômetro 01
5 Motor CC de 6v 01
6 Pilha pequena do tipo AA 04
7 Suporte para quatro pilhas 01
8 Diodo 1N4001 01
9 Transistor TIP120 01
98
Segue abaixo o esquema do projeto. A imagem do projeto será a sua referência para a
conexão correta dos componentes.
O primeiro passo é conectar os componentes na protoboard. Neste caso o diodo, o

TIP120 e o potenciômetro. Quero dar uma atenção especial para o diodo, que neste
projeto tem a função de proteger nosso Arduino contra a corrente e tensão inversa
gerada pelo motor CC.
Esteja também atento a posição do diodo observando a barrinha branca em um dos
seus polos e seu posicionamento no projeto, conforme nostrado na imagem do
esquema do projeto. Isso evitará danos ao Arduino.
Posteriormente, conete os fios jumper na protoboard.
Conecte os fios jumper no Arduino obedecendo o esquema do projeto.
Conecte o motor e as pilhas na protoboard. Apesar do Arduino possuir uma saida de
5V o motor não será ligado diretamente nele pelo fato do Arduino não ter capacidade
de fornecer corrente suficiente para o funcionamento do motor.
Por isso vamos usar pilhas comuns do tipo AA para alimentar o nosso motor CC. Usei
um palito de picolé no motor CC para facilitar a visualização da rotação do motor.
99
SCRIPT ARDUINO
Conecte-o no seu computador pelo cabo USB e abra a IDE do Arduino. O código fonte
comentado deste projeto segue abaixo.
1 /*
2 Projeto Arduino controlando um motor CC.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 //pino analógico onde o potenciômetro está conectado.
10 int const potenciometro = 0;
11
12 //pino digital onde o TIP120 está conectado.
13 int const transistor = 9;
14
15 //armazenará o valor lido no potenciômetro.
16 int valPotenciometro = 0;
17
18 //função setup é executada uma vez quando o Arduino é ligado.
19 void setup() {
20
21 //definindo o pino digital 9 como de saída.
22 pinMode(transistor, OUTPUT);
23 }
24
25 //Função loop é executada repetidamente enquanto
26 //o Arduino estiver ligado.
27 void loop() {
28
29 //lendo o valor do potenciômetro (0 até 1023) e
30 //dividindo por 4 para obter um valor entre 0 e 255
31 //que são valores adequados para a base do TIP120.
32 valPotenciometro = analogRead(potenciometro) / 4;
33
34 //atribuindo o valor lido no potenciômetro
35 //a base do TIP120.
36 analogWrite(transistor, valPotenciometro);
37 }
100
RESULTADO
Depois de inserir o código fonte na IDE, agora é só compilar e fazer o upload do mesmo
para o Arduino. Aguarde alguns instantes para a conclusão do upload e logo poderá
girar o potenciômetro para ambos os lados e ver o seu motor CC aumentar e diminuir
a velocidade de rotação.
COMENTÁRIOS
101
Aula 16 - Motor CC com controle de velocidade, LED-s medidores de
potência e buzzer para alerta de potência máxima
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/motor-cc-no-arduino-com-controle-de-velocidade-e-leds-
medidores-de-potencia.html
O QUE VAMOS FAZER?

Montar um motor CC com controle de velocidade, LED-s medidores de potência e
buzzer para alerta de potência máxima.
Neste projeto Arduino vamos desenvolver um controle de velocidade de rotação para

um motor de corrente contínua além disso vamos introduzir um medidor da potência
aplicada usando LED-s e e buzzer para alerta de potência máxima.
Este projeto Arduino funciona assim, a medida que o potenciômetro é girado para um
lado a velocidade de rotação do motor CC aumenta e os LED-s vão acendendo de
acordo com a potência aplicada, se o motor estiver girando no máximo todos os LED-s
ficarão acesos e, quando a luz vermelha acender, a buzina vai soar para indicar a
potência máxima foi atingida e vai parar de soar quando a luz vermelha apagar.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
4 Potenciômetro 01
5 Motor CC de 6v 01
6 Pilha pequena do tipo AA 04
7 Suporte para quatro pilhas 01
8 Diodo 1N4007 01
9 Transistor TIP120 01
10 LED vermelho 01
11 LED verde 01
12 LED amarelo 01
102
Ele vai servir de base para o desenvolvimento do projeto motor CC no Arduino.
O primeiro passo é conectar os componentes (potenciômetro, TIP120, diodo, LED-s e

resistores) na protoboard como na imagem abaixo.
Conecte os fios jumper entre os componentes da protoboard. Veja o esquema do
projeto acima para visualizar os detalhes de cada conexão entre os componentes.
Faça agora as conexões usando os fios jumper entre o Arduino e a protoboard. Os
pinos utilizados no Arduino foram:
• pino analógico A0 foi conectado a perna central do potenciômetro;
• a pernas positivas dos LED-s foram conectadas aos pinos digitais 2, 3, e 4;
• a primeira perna do transistor TIP120, a base, foi conectada ao pino digital 9;
• a perna positiva do buzzer foi conectada ao pino digital 10.
E finalmente conecte o suporte das pilhas e o motor CC na protoboard, conforme o
esquema do projeto. O Arduino pode ser alimentado por uma bateria de 9 volts ou pelo
cabo USB conectado ao computador.
103
SCRIPT ARDUINO
Usando o cabo USB conecte o Arduino ao seu computador execute a IDE do Arduino, copie e cole
o código fonte abaixo na IDE, compile e faça o upload.
1 /*
2 Projeto Arduino controlando a velocidade de um motor cc
3 com mostrador de leds.
4 Por Jota
5 ----------------------------------------
7 ----------------------------------------
8 */
9
10 //pino analógico onde o potenciômetro está conectado.
11 int const potenciometro = 0;
12
13 //pino digital onde o TIP120 está conectado.
14 int const transistor = 9;
15
16 //pinos digitais
17 int const ledVerde = 2; //led verde está conectado.
18 int const ledAmarelo = 3; //led amarelo está conectado.
19 int const ledVermelho = 4; //led vermelho está conectado.
20
21 //armazenará o valor lido no potenciômetro.
22 int valPotenciometro = 0;
23
24 //pino onde o positivo do buzzer será ligado.
25 const int buzzer = 10;
26
27 //void setup é executada uma vez quando o Arduino é ligado.
28 void setup() {
31
32 //definindo o pino digital 9 como de saída.
33 pinMode(transistor, OUTPUT);
34
35 //definindo pinos dos leds como de saída
36 pinMode(ledVerde, OUTPUT);
37 pinMode(ledAmarelo, OUTPUT);
38 pinMode(ledVermelho, OUTPUT);
39
40 //Definindo o pino buzzer como de saída.
41 pinMode(buzzer,OUTPUT);
42 }
43
44 //Função loop é executada repetidamente enquanto
45 //o arduino estiver ligado.
46 void loop() {
47
48 //lendo o valor do potenciômetro (0 até 1023) e
49 //dividindo por 4 para obter um valor entre 0 e 255
50 //que são valores adequados para a base do TIP120.
51 valPotenciometro = analogRead(potenciometro) / 4;
52
53 //atribuindo o valor lido no potenciômetro a
54 //base do TIP120.
55 analogWrite(transistor, valPotenciometro);
56
57 //acendendo e pagando leds conforme posição do
104
58 //potenciômetro
59 controlarLeds();
60
61 //Exibindo o valor do sensor no serial monitor.
62 Serial.println(valPotenciometro);
63
64 }
65
66 void controlarLeds() {
67 //Led verde - acendendo ou apagando conforme
68 //posição do potenciômetro.
69 if (valPotenciometro >= 40) {
71 } else {
73 }
74
75 //Led amarelo - acendendo ou apagando conforme
79 } else {
81 }
82
83 //Led vermelho - acendendo ou apagando conforme
88 tone(buzzer,1500);
89 }
90
91 else {
92
94 //Desligando o buzzer.
95 noTone(buzzer);
96 }
97 }
105
RESULTADO
COMENTÁRIOS
106
Aula 17 - Alarme com sensor de movimentos PIR
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/como-fazer-um-alarme-com-arduino-sensor-de-
movimentos-pir.html
O QUE VAMOS FAZER?
Montar um alarme usando um sensor de movimento PIR.
O sensor PIR (Passive InfraRed sensor) é um sensor eletrônico que mede a luz infravermelha
irradiada de objetos. O sensor PIR também é conhecido como sensor de presença ou sensor de
movimentos, e ao conectá-lo ao Arduino você terá como controlar este sensor e disparar diversas
ações ao detectar movimentos.
Este projeto de alarme é capaz de detectar movimentos em um ambiente disparando um sinal
sonoro e acendendo um LED. Pode ser usado por exemplo na porta de entrada da sua casa ou em
algum cômodo e quando alguém passar por lá o alarme será disparado. Então, se você necessita
ser avisado da presença de alguém em um determinado lugar este projeto é uma opção interessante
e fácil de fazer.
O sensor PIR é fácil de se encontrar, a maioria das lojas virtuais e físicas que vendem Arduinos e/ou
componentes eletrônicos normalmente possuem este sensor. Só verifique se o sensor PIR que você
pretende adquirir possui controle de sensibilidade da detecção de movimentos. Este que usei no
projeto do alarme possui três pinos, controle de sensibilidade e controle de tempo que o sensor fica
"ligado" quando detecta algum movimento.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
Sensor de movimentos/
4 01
presença PIR
5 LED vermelho 01
7 Buzzer de 5 volts 01
8 Bateria de 9 volts 01
Suporte para bateria com plug
9 01
para ligar no Arduino
107
Segue abaixo o esquema detalhado do projeto do Alarme com Arduino e sensor de movimento PIR.
Por meio deste esquema fica mais fácil de se ter uma visão geral, e de como montar corretamente
o projeto.
SCRIPT ARDUINO
1 /*
2 Projeto Arduino - Alarme com Arduino e sensor de movimento PIR
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 //Declaração das variáveis referentes aos pinos digitais.
10 int pinBuzzer = 7;
11 int pinSensorPIR = 8;
12 int pinLed = 9;
13 int valorSensorPIR = 0;
14
15 void setup() {
16 Serial.begin(9600); //Iniciando o serial monitor
17
18 //Definido pinos como de entrada ou de saída
19 pinMode(pinBuzzer,OUTPUT);
20 pinMode(pinSensorPIR,INPUT);
21 pinMode(pinLed,OUTPUT);
22 }
23
24 void loop() {
25 //Lendo o valor do sensor PIR. Este sensor pode assumir 2 valores
26 //1 quando detecta algum movimento e 0 quando não detecta.
27 valorSensorPIR = digitalRead(pinSensorPIR);
28
29 Serial.print("Valor do Sensor PIR: ");
30 Serial.println(valorSensorPIR);
31
32 //Verificando se ocorreu detecção de movimentos
33 if (valorSensorPIR == 1) {
34 ligarAlarme();
108
35 } else {
36 desligarAlarme();
37 }
38 }
39
40 void ligarAlarme() {
41 //Ligando o led
42 digitalWrite(pinLed, HIGH);
43
45 tone(pinBuzzer,1500);
46
47 delay(4000); //tempo que o LED fica acesso e o buzzer toca
48
49 desligarAlarme();
50 }
51
52 void desligarAlarme() {
53 //Desligando o LED
54 digitalWrite(pinLed, LOW);
55
56 //Desligando o buzzer
57 noTone(pinBuzzer);
58 }
RESULTADO
COMENTÁRIOS
109
Aula 18 - Display LCD - Hello World
CRÉDITOS DA AULA
http://www.arduino.cc/en/Tutorial/LiquidCrystalHelloWorld
O QUE VAMOS FAZER?

Montar um display LCD para exibir na tela a frase “Hello World”.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
Display LCD do tipo JHD 162A de
5 01
16 colunas e 2 linhas
110
SCRIPT ARDUINO
1 /*
2 LiquidCrystal Library - Hello World
3
4 Demonstrates the use a 16x2 LCD display. The LiquidCrystal
5 library works with all LCD displays that are compatible with the
6 Hitachi HD44780 driver. There are many of them out there, and you
7 can usually tell them by the 16-pin interface.
8
9 This sketch prints "Hello World!" to the LCD
10 and shows the time.
11
12 The circuit:
13 * LCD RS pin to digital pin 12
14 * LCD Enable pin to digital pin 11
15 * LCD D4 pin to digital pin 5
19 * LCD R/W pin to ground
20 * LCD VSS pin to ground
21 * LCD VCC pin to 5V
22 * 10K resistor:
23 * ends to +5V and ground
24 * wiper to LCD VO pin (pin 3)
25
26 Library originally added 18 Apr 2008
27 by David A. Mellis
28 library modified 5 Jul 2009
29 by Limor Fried (http://www.ladyada.net)
30 example added 9 Jul 2009
31 by Tom Igoe
32 modified 22 Nov 2010
33 by Tom Igoe
34 modified 7 Nov 2016
35 by Arturo Guadalupi
36
37 This example code is in the public domain.
38
39 http://www.arduino.cc/en/Tutorial/LiquidCrystalHelloWorld
40
41 */
42
43 // include the library code:
44 #include <LiquidCrystal.h>
45
46 // initialize the library by associating any needed LCD interface pin
47 // with the Arduino pin number it is connected to
48 const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
49 LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
50
51 void setup() {
52 // set up the LCD's number of columns and rows:
53 lcd.begin(16, 2);
54 // Print a message to the LCD.
55 lcd.print("hello, world!");
56 }
57
58 void loop() {
59 // set the cursor to column 0, line 1
60 // (note: line 1 is the second row, since counting begins with 0):
61 lcd.setCursor(0, 1);
62 // print the number of seconds since reset:
63 lcd.print(millis() / 1000);
64 }
111
RESULTADO
COMENTÁRIOS
112
Aula 19 - Display LCD com dois potenciômetros
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-com-display-lcd.html
O QUE VAMOS FAZER?
Montar display LCD 16x2 do tipo JHD 162A.
Um display LCD eleva o seu projeto a outro nível, pois possibilita uma saída mais amigável e a
possibilidade de interação por parte dos usuários.
Usar displays LCDs em projetos Arduino ao contrário do que parece é bem fácil, pois todas as
funcionalidades já estão codificadas na biblioteca LiquidCrystal.h que será incluída, é terá suas
funções chamadas a partir do nosso programa desenvolvido para este projeto.
Outro ponto importante é o uso de dois potenciômetros que servem para controlar o brilho e o
contraste da tela LCD permitindo que você defina um nível adequado de visibilidade para o display
LCD.
Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
Display LCD do tipo JHD 162A de
4 01
16 colunas e 2 linhas
5 Potenciômetro de 10K ohms 02

113
Segue abaixo o esquema de montagem do projeto, que servirá como referencia de ligação entre os
componentes ao longo do post.
Segue abaixo o datasheet, detalhando a funcionalidade de cada pino, do display LCD JHD 162A
que foi usado neste projeto.
A imagem abaixo mostra o verso do display LCD JHD 162A. No canto inferior direito vemos o código
deste display.
114
Vamos iniciar a montagem do nosso projeto conectando o display LCD na protoboard. Neste caso
o pino 1 do display LCD foi conectado a coluna 0 da protoboard.
115
Agora conecte o 5V e o GND do Arduino na protoboard. Conecte os dois potenciômetros e também
os ligue ao 5V e GND. Neste caso o fio vermelho é o 5V e o preto e o GND.
Agora chegou a hora de ligar o display LCD ao Arduino. A ligação será feita da seguinte forma.
• pino 1 do LCD ligado ao GND do Arduino;
• pino 2 do LCD ligado ao 5V do Arduino;
• pino 3 do LCD ligado ao pino central do primeiro potênciômetro (controle de contraste);
• pino 4 do LCD ligado ao pino digital 9 do Arduino;
• pino 15 do LCD ligado ao pino central do segundo potênciômetro (controle do brilho);
• pino 16 do LCD ligado ao GND do Arduino.
Lembrando que você poderá verificar o esquema de montagem do projeto no início, que mostra
com detalhes como as ligações entre os componentes foram feitas.
116
Agora chegou a hora de programar o Arduino. Segue abaixo o código fonte comentado deste
projeto, lembrando que as mensagens exibidas no display LCD, pelo comando lcd.print poderão ser
alteradas.
SCRIPT ARDUINO
Código fonte do projeto.

1 /*
2 Projeto Arduino com LCD.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 //Define a utilização da biblioteca para controle de telas LDCs.
10 #include "LiquidCrystal.h"
11
12 //Criando um objeto da classe LiquidCrystal e
13 //inicializando com os pinos da interface.
14 LiquidCrystal lcd(9, 8, 5, 4, 3, 2);
15
16 void setup() {
17 //Inicializando o LCD e informando o tamanho de 16 colunas e 2
18 linhas
19 //que é o tamanho do LCD JHD 162A usado neste projeto.
21 }
22
23 void loop() {
24 lcd.clear(); //limpa o display do LCD.
25 lcd.print("Oi!!! "); //imprime a string no display do LCD.
26 delay(2000);
27
28 lcd.setCursor(0,1); //posiciona cursor na coluna 0 linha 1 do LCD
29 lcd.print("Tudo Bem???"); //imprime a string no display do LCD.
30 delay(2000);
31
32 lcd.clear();
33 lcd.print("Quer aprender");
34 lcd.setCursor(0,1);
35 lcd.print("este projeto?");
36 delay(4000);
37
38 lcd.clear();
39 lcd.print("www.ComoFazerAsCoisas.com.br");
40 delay(1000);
41
42 //Rolando o display para a esquerda 12 vezes
43 for (int i = 0; i < 12; i++) {
44 lcd.scrollDisplayLeft();
45 delay(600);
46 }
47
48 delay(1000);
49 }
RESULTADO
117
Após transferir o código fonte para a IDE do Arduino compile-o e depois faça o upload do mesmo.
Ajuste os potenciômetros para que as mensagens fiquem visíveis e pronto, seu projeto foi concluído.
COMENTÁRIOS
118
Aula 20 - Display LCD com sensor de temperatura e luminosidade
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/projeto-arduino-com-display-lcd-sensor-de-temperatura-e-
sensor-de-luz.html
O QUE VAMOS FAZER?

Montar um display LCD com sensor de temperatura e sensor de luminosidade.
Como desenvolver o projeto Arduino com display LDC, que mede a temperatura por meio de um
sensor LM35 e mede a luminosidade por meio de um sensor LDR (do inglês Light Dependent
Resistor).
Além disso você poderá controlar o brilho e contraste do display LDC por dois potenciômetros. Este
projeto Arduino vai te mostrar como trabalhar com displays LDC do tipo JHD 162A, de 16 colunas e
2 linhas, que é um tipo comum e fácil de encontrar e com um preço acessível, e te mostrará também
como realizar a leitura dos sensores de temperatura e luminosidade.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
5 Sensor de temperatura LM35 01
Sensor LDR (Light Dependent
6 01
Resistor)
119
O esquema do projeto, logo abaixo, e que servirá de base durante todo o desenvolvimento do
mesmo, te mostra com detalhes todos os componentes e as conexões entre eles, que serão tratadas
com detalhes mais adiante.
Além do esquema precisamos saber de mais alguns detalhes técnicos sobre essas ligações. Vamos
começar pelo datasheet do display LCD JHD 162A, que mostra a finalidade de cada um dos pinos
do display LCD. Caso o seu display não seja um JHD 162A você poderá procurar na internet pelo
datasheet do mesmo e assim adaptar para esse projeto.
120
Segue abaixo a descrição de como deverão ser feitas as ligações entre o display LDC, o Arduino, e
os potenciômetros que controlam o brilho e o contrate do LCD.
121
Agora trataremos do sensor de temperatura LM35. Segue abaixo uma imagem que detalha a função
de cada pino do sensor.
A conexão será feita da seguinte forma:

• pino 5V do LM35 no 5V do Arduino;
• pino central do LM35 no pino analógico A1 do Arduino;
• pino GND do LM35 no GND do Arduino.
O sensor de luz será ligado da seguinte forma:
• uma perna do sensor de luz LDR no 5V do Arduino;
• a outra perna do sensor de luz LDR no pino analógico A0 e também no GND do Arduino, a
ligação no GND será feita pelo resistor. Para detalhes veja o esquema do projeto.
Após feitas todas as conexões entre Arduino, protoboard e componentes, chegou a hora de
programar o seu Arduino para que ele assuma as funções propostas neste projeto. Então conecte
122
o seu Arduino ao computador por meio do cabo USB, execute a IDE de programação do Arduino e
introduza o código fonte abaixo.
SCRIPT ARDUINO
Código fonte completo e comentado.

1 /*
2 Projeto Arduino com LCD, sensor de luz e de temperatura.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8 #include "LiquidCrystal.h"
9 //#include <Limits.h>
10 int sensorLuz = 0; //Pino analógico que o sensor de luz está conectado.
11 int sensorTemp = 1; //Pino analógico que o sensor de temperatura está conectado.
12
13 //Variáveis
14 int valorSensorLuz = 0; //usada para ler o valor do sensor de luz.
15 int valorSensorTemp = 0; //usada para ler o valor do sensor de temperatura.
16
20
21 void setup() {
22 //Inicializando o LCD e informando o tamanho de 16 colunas e 2 linhas
25
28 }
29
30 void loop() {
31 // Faz a leitura da tensao no Sensor de Temperatura
32 int SensorTempTensao=analogRead(sensorTemp);
33
34 // Converte a tensao lida
35 float valorSensorTemp=SensorTempTensao*5;
36 valorSensorTemp/=1024;
37
38 // Converte a tensao lida em Graus Celsius
39 float TemperaturaC=(valorSensorTemp-0.5)*100;
40
41 //Exibindo valor da leitura do sensor de temperatura no display LCD.
43 lcd.print("Temp: "); //imprime a string no display do LCD.
44 lcd.print(TemperaturaC);
45 lcd.write(B11011111); //Simbolo de graus celsius
46 lcd.print("C");
47
48 //Lendo o valor do sensor.
49 int valorSensorLuz = analogRead(sensorLuz);
50
51 //Exibindo valor da leitura do sensor de luz no display LCD.
52 lcd.setCursor(0,1); //posiciona o cursor na coluna 0 linha 1 do LCD.
53 lcd.print("Luz: "); //imprime a string no display do LCD.
54 lcd.print(valorSensorLuz);
55
123
56 delay(2000); //aguarda 2 segundos
57 }
RESULTADO
Agora compile o código fonte e faça o upload para o Arduino. O projeto começará a funcionar,
mostrando a temperatura do ambiente e a intensidade de luz, que vai de 0 até 1023. Regule o brilho
e o contraste do display LCD, pelos potenciômetros, para ficar bem nítido a exibição dos valores de
temperatura e luz.
COMENTÁRIOS
124
Aula 21 - Display LCD com dois potenciômetros e servomotor
controlado com um potenciômetro
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/arduino-com-servomotor-robotico-e-display-lcd.html
O QUE VAMOS FAZER?
Montar um display LCD com dois potenciômetros e servomotor controlado com um potenciômetro.
Uma das diferenças de um robô para um aparelho eletrônico comum é que o robô se movimenta
para realizar tarefas. Para se movimentar um robô usa motores de diversos tipos, como motores de
passo, motores de corrente contínua e servomotores. E no projeto Arduino com servomotor robótico
e display LCD faremos um servomotor se movimentar e também trataremos estes movimentos
exibindo as direções do braço do servomotor no display LCD. Como um do nosso objetivo com os
projetos em Arduino, aqui do site ComoFazerAsCoisas, é chegar a construção de robôs de diversos
tipos, estamos apresentando os princípios básicos, que quando unidos permitirão a construção de
um robô completo.
O projeto Arduino com servomotor e display LCD, permite que você controle os movimentos de um
servomotor por um potenciômetro giratório. Quando você gira o potenciômetro para um lado ou para
o outro o braço do servomotor acompanha estes movimentos e ainda é mostrado no display LCD
em tempo real em que direção o braço do servomotor está, no final deste post tem o vídeo que
mostra este projeto em funcionamento.
Aplicando o princípio deste projeto, você poderia por exemplo construir um guincho robótico ou um
braço robótico.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
5 Micro servomotor 01
Display LCD do tipo JHD162A,
6 01
de 16 colunas por 2 linhas
125
O servomotor que usamos neste projeto é um microservo TG9E da Turnigy, que é um dos bons
custo/benefício do mercado. Ele é um servo bem pequeno e leve, tem um preço camarada, quando
comparado a outros servos, e pode ser usado em muitos projetos de robótica. Este microservo
também é muito usado em aeromodelos e carrinhos controle remoto. Nos potenciômetros desse
projeto usei knobs para facilitar na hora de girá-los.
Segue abaixo o esquema do projeto, que servirá de base para a ligação entre todos os componentes
e o Arduino, e será nossa referência durante o desenvolvimento do projeto físico.
Segue abaixo o datasheet, detalhando a funcionalidade de cada pino, do display LCD JHD 162A
que foi usado neste projeto.
Segue abaixo o detalhamento de como ligar o display LCD ao Arduino.

126
Segue abaixo o detalhamento da ligação do servomotor e do potenciômetro que irá controlar o
servomotor.
• pino central do potenciômetro de controle do servomotor no pino analógico A0 do Arduino;
• fio positivo do servomotor no 5V do Arduino;
• fio negativo do servomotor no GND do Arduino;
• fio de controle do servomotor no pino digital 12 do Arduino.
Lembrando que você poderá verificar o esquema de montagem do projeto no início deste post, que
mostra com detalhes como foram feitas as ligações entre os componentes.
Bem, então depois de fazer todas as ligações entre os componentes, concluindo o projeto físico,
chegou a hora de programar o Arduino para que ele faça o controle do servomotor e também informe
a posição do mesmo no display LDC. Então conecte o seu Arduino ao computador, usando o cabo
USB, e execute a IDE do Arduino.
127
SCRIPT ARDUINO
Segue abaixo o código fonte completo e comentado deste projeto.

1 /*
2 Projeto Arduino - servomotor com display LCD.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 #include "LiquidCrystal.h" //biblioteca para controle de telas LDCs
10 #include "Servo.h" //biblioteca para controle de servomotores
11
15 Servo servoMotorObj; //Criando um objeto da classe Servo
16
17 //pino analógico onde o potenciômetro está conectado
18 int const potenciometroPin = 0;
19
20 //pino digital associado ao controle do servomotor
21 int const servoMotorPin = 12;
22
23 //usada para armazenar o valor lido no potenciômetro
24 int valPotenciometro;
25
26 void setup() {
27 //Inicializando o LCD e informando o tamanho de 16 colunas e 2 linhas
30
31 //associando o pino digital ao objeto da classe Servo
32 servoMotorObj.attach(servoMotorPin);
33 }
34
35 void loop() {
36 //lendo o valor do potenciômetro (intervalo entre 0 e 1023)
37 valPotenciometro = analogRead(potenciometroPin);
38 //mapeando o valor do potenciômetro para a escala do servo (0 e 180)
39 valPotenciometro = map(valPotenciometro, 0, 1023, 0, 180);
40
41 //definindo o valor/posição do servomotor
42 servoMotorObj.write(valPotenciometro);
43
45 lcd.print("Servomotor"); //imprime a string no display do LCD.
46
47 lcd.setCursor(0,1); //posiciona o cursor na coluna 0 linha 1 do LCD.
48
49 //Mostrando no LCD a posição do braço do servomotor
50 if (valPotenciometro < 90) {
51 lcd.print("Lado direito");
52 }
53 if (valPotenciometro == 90) {
54 lcd.print("Centro");
55 }
56 if (valPotenciometro > 90) {
57 lcd.print("Lado esquerdo");
58 }
59
60 delay(30);
61 }
RESULTADO
128
Depois de copiar o código fonte na IDE compile e faça o upload para o Arduino. Agora gire o
potenciômetro para um lado e para o outro e veja que o braço do servomotor "segue" estes
movimentos.
COMENTÁRIOS
129
Aula 22 - Relógio simples com display LCD
CRÉDITOS DA AULA
https://www.tinkercad.com/things/1y5mbRo5UOP-aula-24-relogio-simples-com-display-lcd/editel
O QUE VAMOS FAZER?

.
Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
4 Sensor de distância ultrassônico 03
Motor de engrenagem de uso
5 02
não profissional
Display LCD do tipo JHD162A,
6 01
de 16 colunas por 2 linhas
4 baterias, AAA, sim Bateria
7 01
1,5V
8 Micro servo 01
9 Acionador de motor de ponte H 01
SCRIPT ARDUINO
130
3
4 // Calibrate your Region time befor running the code
5 int sec;
6 int mint = 5;
7 int hur = 12;
8 int dy = 23;
9 int mnth = 8;
10 int yer = 2019;
11
12 void setup() {
15 }
16
17 void loop() {
18 for (sec = 0 ; sec < 60 ; sec++) {
19 lcd.setCursor(6, 0); lcd.print(":");
20 lcd.setCursor(9, 0); lcd.print(":");
21 Serial.print(mint); Serial.print(":");
22 Serial.println(sec);
23 if (hur <= 9) {
24 lcd.setCursor(4, 0); lcd.print("0");
25 lcd.setCursor(5, 0); lcd.print(hur);
26 }
27 else if (hur > 9) {
28 lcd.setCursor(4, 0); lcd.print(hur);
29 }
30
31 if (mint <= 9) {
33 lcd.setCursor(8, 0); lcd.print(mint);
34 }
35 else if (mint > 9) {
36 lcd.setCursor(7, 0); lcd.print(mint);
37 }
38
39 if (sec <= 9) {
41 lcd.setCursor(11, 0); lcd.print(sec);
42 }
43 else if (hur > 9) {
44 lcd.setCursor(10, 0); lcd.print(sec);
45 }
46
47 lcd.setCursor(5, 1); lcd.print("/");
48 lcd.setCursor(8, 1); lcd.print("/");
49
50 if (dy <= 9) {
52 lcd.setCursor(4, 1); lcd.print(dy);
53 }
54 else if (dy > 9) {
55 lcd.setCursor(3, 1); lcd.print(dy);
56 }
57
58 if (mnth <= 9) {
60 lcd.setCursor(7, 1); lcd.print(mnth);
61 }
62 else if (mnth > 9) {
63 lcd.setCursor(6, 1); lcd.print(mnth);
64 }
65
66 lcd.setCursor(9, 1); lcd.print(yer);
67
68 delay(1000);
69 // lcd.clear();
70 }
131
71 mint = mint + 1;
72 if (mint == 60) {
73 hur = hur + 1;
74 mint = 0 ;
75 }
76
77 if (hur == 24) {
78 hur = 0;
79 dy = dy + 1;
80 }
81
82 if (dy == 31) {
83 mnth = mnth + 1;
84 dy = 0;
85 }
86
87 if (mnth == 13) {
88 yer = yer + 1;
89 mnth = 0;
90 }
91 }
RESULTADO
COMENTÁRIOS
132
Aula 23 - Montagem de relógio com módulo DS1302RTC
CRÉDITOS DA AULA
https://www.arduinoecia.com.br/2014/11/arduino-modulo-rtc-ds1302.html
O QUE VAMOS FAZER?

Programa para mostrar o dia da semana por extenso com data e hora.
O módulo é controlado pelo DS1302, um chip do tipo RTC (Real Time Clock, ou Relógio de Tempo
Real), com funções de data, hora e calendário. Ele é capaz de fornecer as informações de horas,
minutos, segundos, dia da semana, data, mês e ano, e ajusta automaticamente os dados referentes
aos meses com menos de 31 dias e também anos bissextos.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
4 Módulo RTC DS1302 01
E abaixo a disposição do CI DS1302 no módulo, que na verdade não possui muitos componentes
adicionais, apenas o cristal de 32.768 kHz e a bateria (CR2032) para manter a alimentação do chip
em caso de falta de energia:
O CI aceita alimentação de 2 à 5.5V, logo podemos ligar o módulo utilizando os pinos 3.3V ou 5V
do Arduino.
São utilizados três pinos para conexão ao Arduino: RST (Reset ou CE - Chip Enable), DATA (I/O) e
CLK (ou SCLK / Serial Clock). Para testes vou alimentar o módulo com os 5V do Arduino:
133
Como pinos de dados usamos os pinos 6, 7 e 8 do Arduino. Você pode escolher outros pinos do
Arduino e mudar essa configuração nas linhas iniciais do programa.
Existe um artigo no site oficial do Arduino, mostrando em detalhes como ler as informações do
DS1302. Para quem gosta de entender como essa comunicação é feita, byte a byte, vale a pena
dar uma olhada nessa página: http://playground.arduino.cc/Main/DS1302.
Para a maioria das aplicações esse código é bem extenso e não muito simples de entender, por
isso o pessoal da Virtuabotix adaptou esse código e criou uma biblioteca chamada virtuabotixRTC
(clique aqui para efetuar o download da biblioteca). Com ela fica muito fácil de extrair as informações
do DS1302 e utilizá-las junto com outras funções do Arduino.
Note que no início do programa temos essa linha, que serve para determinar a data e hora atuais :
myRTC.setDS1302Time(<segundos>, <minutos>, <hora>, <dia da semana>, <dia do mês>, <mês>,

<ano>)
Uma vez setada a data e a hora, a linha acima deve ser comentada e o programa novamente
carregado no Arduino.
134
SCRIPT ARDUINO

1 // Example sketch for interfacing with the DS1302 timekeeping chip.
2 //
3 // Copyright (c) 2009, Matt Sparks
4 // All rights reserved.
5 //
6 // http://quadpoint.org/projects/arduino-ds1302
7 #include <stdio.h>
8 #include <DS1302.h>
9
10 namespace {
11
12 // Set the appropriate digital I/O pin connections. These are the pin
13 // assignments for the Arduino as well for as the DS1302 chip. See the DS1302
14 // datasheet:
15 //
16 // http://datasheets.maximintegrated.com/en/ds/DS1302.pdf
17 const int kCePin = 5; // Chip Enable
18 const int kIoPin = 6; // Input/Output
19 const int kSclkPin = 7; // Serial Clock
20
21 // Create a DS1302 object.
22 DS1302 rtc(kCePin, kIoPin, kSclkPin);
23
24 String dayAsString(const Time::Day day) {
25 switch (day) {
26 case Time::kSunday: return "Sunday";
27 case Time::kMonday: return "Monday";
28 case Time::kTuesday: return "Tuesday";
29 case Time::kWednesday: return "Wednesday";
30 case Time::kThursday: return "Thursday";
31 case Time::kFriday: return "Friday";
32 case Time::kSaturday: return "Saturday";
33 }
34 return "(unknown day)";
35 }
36
37 void printTime() {
38 // Get the current time and date from the chip.
39 Time t = rtc.time();
40
41 // Name the day of the week.
42 const String day = dayAsString(t.day);
43
44 // Format the time and date and insert into the temporary buffer.
135
45 char buf[50];
46 snprintf(buf, sizeof(buf), "%s %04d-%02d-%02d %02d:%02d:%02d",
47 day.c_str(),
48 t.yr, t.mon, t.date,
49 t.hr, t.min, t.sec);
50
51 // Print the formatted string to serial so we can see the time.
52 Serial.println(buf);
53 }
54
55 } // namespace
56
57 void setup() {
59
60 // Initialize a new chip by turning off write protection and clearing the
61 // clock halt flag. These methods needn't always be called. See the DS1302
62 // datasheet for details.
63 rtc.writeProtect(false);
64 rtc.halt(false);
65
66 // Make a new time object to set the date and time.
67 // Sunday, September 22, 2013 at 01:38:50.
68 Time t(2019, 4, 20, 16, 42, 00, Time::kSaturday);
69
70 // Set the time and date on the chip.
71 rtc.time(t);
72 }
73
74 // Loop and print the time every second.
75 void loop() {
76 printTime();
77 delay(1000);
78 }
136
RESULTADO
COMENTÁRIOS
137
Aula 24 - Sensor de obstáculos ultrassônico HC-SRO4
CRÉDITOS DA AULA
http://www.comofazerascoisas.com.br/arduino-com-sensor-de-obstaculos-ultrasonico-HC-
SRO4.html
O QUE VAMOS FAZER?
Parte superior do formulário

Montar um sensor ultrassônico no Arduino.
O sensor ultrassônico em muitos casos são os olhos de um robô. Ele é capaz de detectar a distância
obstáculos que estão à frente de um robô móvel, possibilitando assim uma manobra nos
movimentos antes que ocorra uma colisão.
O casamento entre Arduino e o sensor ultrassônico te dará total controle, permitindo que você
programe da forma mais conveniente para o seu projeto os movimentos do seu robô.
No caso deste projeto é usado um Arduino UNO R3 e um sensor ultrassônico HC-SRO4. O sensor
HC-SRO4 é fácil de encontrar e tem um bom preço. Além disso é bem fácil de controlá-lo por meio
do Arduino, pois o mesmo só possui 4 pinos que serão explicados mais adiante.
O HC-SRO4 é um sensor ultrassônico que usa um sonar para detectar objetos a distância de 2 cm
até 4 metros. Seu sistema de detecção de objetos é como o dos golfinhos. Esse sensor é muito
utilizado na robótica para construção de robôs, que se movimentam e devem desviar ou evitar
obstáculos.
Dentre suas características podemos destacar:

• Trabalha com microcontroladores com entradas digitais, como o Arduino e o PIC, além de
outros;
• É capaz de datectar objetos entre 2 cm e 4 metros de distância;
• Sua operação não é afetada pela luz solar;
• Revestimentos acústicos podem atrapalhar a operação do sensor HC-SRO4;
• Possui o transmissor e o receptor de ultrasom no chip, não necessitando de componentes
adicionais;
• Possui uma resolução de 0,3 cm;
• Ângulo de medição de 30 graus;
• suas dimensões são de 45mm x 20mm 15mm.
Abaixo segue a função de cada um dos pinos do HC-SRO4:
• VCC - 5V (podendo variar de 4,5V até 5,5V)

• Trig - Entrada do sensor (gatilho)
• Echo - Saída do sensor (Eco)
• GND - Ground (terra)
Nr O Material Qtde
138
1 Arduino UNO R3 01
2 Protoboard 01
5 Sensor HC-SRO4 01
6 220 Ω Resistor 03
7 LED Vermelho 01
8 LED Amarelelo 01
9 LED Verde 01
O funcionamento do projeto é simples, à medida que aproxima algum objeto do sensor os LED-s
acendem conforme a distância do objeto. O LED verde se estiver longe, o amarelo se estiver em
uma distância média e o vermelho se estiver próximo.
As distâncias de acendimento dos LED-s são programáveis, se você quiser alterar é só fazer isso
no código fonte do projeto.
O primeiro passo é instalar a biblioteca do sensor HC-SRO4 para que seu programa funcione. Para
isso baixe a biblioteca em seu computador, depois descompacte o arquivo. Após descompactar uma
pasta chamada HCSR04Ultrasonic será criada no seu computador. Copie esta pasta para a pasta
libraries da IDE do Arduino e pronto, agora você pode usar os recursos da biblioteca em seus
programas.
As ligações ficaram da seguinte forma:
• portas digitais 2, 3 e 4 do Arduino ligadas nos resistores, que por sua vez estão ligados nas
pernas positivas dos LED-s;
• pernas negativas dos LED-s no GND (terra) do Arduino;
• pino VCC do sensor ultrasônico HC-SRO4 no 5V do Arduino;
• pino TRIG do sensor HC-SRO4 na porta digital 6 do Arduino;
• pino ECHO do sensor HC-SRO4 na porta digital 7 do Arduino;
• pino GND do sensor HC-SRO4 no GND do Arduino.
139
Agora monte seu projeto físico conforme o esquema abaixo.
SCRIPT ARDUINO
Abaixo segue o código fonte deste projeto:
1 int distanciaLimite = 0;
2 int cm = 0;
3 int polegadas = 0;
4
5 //Declaração das constantes referentes aos pinos digitais.
9
10 //Definindo as portas digitais do Trigger - 6 - e Echo - 7
11
12 long readUltrasonicDistance(int triggerPin, int echoPin)
13 {
14 pinMode(triggerPin, OUTPUT); // Zera o trigger
15 digitalWrite(triggerPin, LOW);
16 delayMicroseconds(2);
17
18 // Configura a porta digital do Trigger para estado HIGH por 10
19 microssegundos
20 digitalWrite(triggerPin, HIGH);
22 digitalWrite(triggerPin, LOW);
23 pinMode(echoPin, INPUT);
24
25 // Lê a porta digital Echo e retorna o tempo da onda de som em
26 microssegundos
140
27 return pulseIn(echoPin, HIGH);
28 }
29
30 void setup()
31 {
33
34 pinMode(ledVerde, OUTPUT);
35 pinMode(ledAmarelo, OUTPUT);
36 pinMode(ledVermelho, OUTPUT);
37 }
38
39 void loop()
40 {
41 // Definindo a distância máxima para acender os LED-s
42 distanciaLimite = 350;
43 // Mede o tempo do sinal em cm
44 cm = 0.01723 * readUltrasonicDistance(7, 6);
45 // Converte para polegadas dividindo por 2.54
46 polegadas = (cm / 2.54);
47
48 Serial.print(cm);
49 Serial.print("cm, ");
50 Serial.print(polegadas);
51 Serial.println("in");
52 if (cm > distanciaLimite) {
53 digitalWrite(ledVerde, LOW);
54 digitalWrite(ledAmarelo, LOW);
55 digitalWrite(ledVermelho, LOW);
56 }
57 if (cm <= distanciaLimite && cm > distanciaLimite - 100) {
58 digitalWrite(ledVerde, HIGH);
59 digitalWrite(ledAmarelo, LOW);
61 }
62 if (cm <= distanciaLimite - 100 && cm > distanciaLimite - 250) {
64 digitalWrite(ledAmarelo, HIGH);
66 }
67 if (cm <= distanciaLimite - 250 && cm > distanciaLimite - 350) {
70 digitalWrite(ledVermelho, HIGH);
71 }
72 if (cm <= distanciaLimite - 350) {
75 digitalWrite(ledVermelho, HIGH);
76 }
77 delay(100); // Espera 100 milissegundos
78 }
141
RESULTADO
Conecte o Arduino ao seu computador, execute a IDE do Arduino e copie o código fonte acima.
Compile e faça o upload para o Arduino e o projeto está concluído.
COMENTÁRIOS
142
Aula 25 - Carro robótico com sensor de obstáculo e servomotor
CRÉDITOS DA AULA
O QUE VAMOS FAZER?

Montar um carro robótico com sensor de obstáculo e servomotor.
Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
Motor de engrenagem de uso não
5 02
profissional
Display LCD do tipo JHD162A, de 16
6 01
colunas por 2 linhas
7 4 baterias, AAA, sim Bateria 1,5V 01
8 Micro servo 01
143
SCRIPT ARDUINO
1 #define mr1 6
2 #define mr2 5
3 #define ml1 9
4 #define ml2 10
5 #define servo_pulse 7
6 #define triger 8
7
9
10 int distance, select, pos=0;
11
12 Servo myservo;
13
14 void setup()
15 {
17 myservo.attach(7);
18
19 for(int i=0 ; i<11 ; i++)
20 {
21 pinMode(i, OUTPUT);
22 }
23 }
24
25 // Returna a distância da onda de som do sensor em cm
26 int getDistance()
27 {
28 int distance;
29 unsigned long pulseduration=0;
30 // get the raw measurement data from Ping)))
31 // set pin as output so we can send a pulse
32 pinMode(triger, OUTPUT);
33
34 // set output to LOW
35 digitalWrite(triger, LOW);
37
38 // send the 5uS pulse out to activate Ping)))
39 digitalWrite(triger, HIGH);
41 digitalWrite(triger, LOW);
42
43 // change the digital pin to input to read the incoming pulse
44 pinMode(triger, INPUT);
45
46 // measure the length of the incoming pulse
47 pulseduration=pulseIn(triger, HIGH);
48
49 // divide the pulse length in half
50 pulseduration=pulseduration/2;
51
52 // convert to centimeters
53 distance = int(pulseduration/29);
54 return distance;
55 }
56
57 void goForward()
144
58 {
59 digitalWrite(mr1, HIGH);
60 digitalWrite(mr2, LOW);
61 digitalWrite(ml1, HIGH);
62 digitalWrite(ml2, LOW);
63 }
64
65 void goBack()
66 {
67 digitalWrite(mr1,LOW);
71 }
72
73 void turnLeft()
74 {
76 digitalWrite(mr2, LOW);
}
void turnRight()
{
digitalWrite(mr1,LOW);
digitalWrite(mr2,HIGH);
digitalWrite(ml1,HIGH);
digitalWrite(ml2, LOW);
}
void STOP()
{
}
void loop()
{
Serial.print(distance);
myservo.write(90);
delay(15);
distance = int (getDistance());
Serial.print(distance);
while(distance >20)
{
goForward();
distance=getDistance();
}
while(distance <= 20)

{
STOP();
delay(1000);
myservo.write(pos);
select = pos;
pos+=45;
if(pos == 225)
pos = 0;
distance=getDistance();
}
145
myservo.write(90);
switch(select)
{
case 0:
turnLeft();
delay(250);
STOP();
break;
case 45:
turnLeft();
delay(500);
STOP();
break;
case 135:
turnRight();
delay(250);
STOP();
break;
case 180:
turnRight();
delay(500);
STOP();
break;
}
}
RESULTADO
COMENTÁRIOS
146
Aula 26 - Carro robótico controlado com controle remoto
infravermelho
CRÉDITOS DA AULA
O QUE VAMOS FAZER?

.
Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
4 Sensor Infravermelho 01
5 Motor CC 02
7 LED Vermelho 01
SCRIPT ARDUINO
1 #include <IRremote.h>
2
3 IRrecv rc(11);
4 decode_results results;
5
6 //Init Motors
7
8 const int PWM_M1 = 5;
9 const int IN1_M1 = 2;
11
12 const int PWM_M2 = 6;
15
16 int speed = 100;
17
18 void setup(){
147
20 rc.enableIRIn();
21
22 pinMode(PWM_M1,OUTPUT);
23 pinMode(PWM_M2,OUTPUT);
24
25 pinMode(IN1_M1,OUTPUT);
27
30 }
31
32 void loop(){
33 if (rc.decode(&results)){
34 switch(results.value){
35 case 0xFD00FF://power
36 break;
37 case 0xFD807F://vol+
38 forward();
39 break;
40 case 0xFD40BF://func/stop
41 break;
42 case 0xFD20DF://|<<
43 turnLeft();
44 break;
45 case 0xFDA05F://>||
46 stop();
47 break ;
48 case 0xFD609F://>>|
49 turnRight();
50 break ;
51 case 0xFD10EF://down arrow
52 speedDown();
53 break ;
54 case 0xFD906F://vol-
55 backward();
56 break ;
57 case 0xFD50AF://up arrow
58 speedUp();
59 break ;
60 }
61 rc.resume();
62 }
63 }
64
65 void forward(){
66 Serial.println("forward");
67 analogWrite(PWM_M1, speed);
69
70 digitalWrite(IN1_M1, HIGH);
71 digitalWrite(IN2_M1, LOW);
72
75 }
76
77 void backward(){
78 Serial.println("backward");
81
148
84
87 }
88
89 void turnLeft(){
90 Serial.println("turnLeft");
91 analogWrite(PWM_M1, 0);
93
96
99 }
100
101 void turnRight(){
102 Serial.println("turnRight");
104 analogWrite(PWM_M2, 0);
105
108
111 }
112
113 void stop(){
114 Serial.println("stop");
117
120 }
121
122 void speedUp(){
123 Serial.println("speedUp");
124 speed+=10;
125 if(speed>255) speed =255;
128 }
129
130 void speedDown(){
131 Serial.println("speedDown");
132 speed-=10;
133 if(speed<0) speed =0;
136 }
149
RESULTADO
COMENTÁRIOS
150
Aula 27 - Braço robótico com 4 servomotores controlados com
potenciômetros
CRÉDITOS DA AULA
https://www.sinoning.com/collections/robot-arm/products/acrylic-mechanics-handle-robot-4-dof-
arm-arduino-created-learning-kit-sg90
O QUE VAMOS FAZER?

.
This is a classic 4-degree-of-freedom machine is inspired by industrial robots. The kit is suitable for
guest space, college students, high school students use. You can use Arduino, 51 single-chip, model
remote control, etc. to control the robot.
The product is a spare part that is not assembled.
Weight: 200g
Shipping list:
A set of acrylic cutting parts
A pack of screws
4 sg90 sevos
Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
4 Micro servo SG90 04
6 15 kΩ Potenciômetro 04
7 Fonte de energia 5volts 01
8 Kit de montagem da estrutura 01
151
152
153
154
155
SCRIPT ARDUINO
2
3 Servo Servobase,Servoderecha,Servoizquierda, Servopinza; //Declaramos que
4 queremos controlar un Servo, al cual le vamos a poner un nombre
5 cualquiera
6
7 int potenciometro1 = 0; //El pin análogo donde va conectado el
8 Potenciómetro 1
10 Potenciómetro 2
12 Potenciómetro 3
14 Potenciómetro 4
15
16 int val1; //El valor a leer por el puerto análogo
20
21 void setup()
22 {
23 Servopinza.attach(13); //El pin al cual conectaremos nuestro Servo PINZA
24 Servoderecha.attach(12); //El pin al cual conectaremos nuestro Servo
25 DERECHA
26 Servoizquierda.attach(11); //El pin al cual conectaremos nuestro Servo
27 IZQUIERDA
28 Servobase.attach(10); //El pin al cual conectaremos nuestro Servo BASE
29 }
156
30
31 void loop()
32 {
33 val1= analogRead(potenciometro1); //Aquí le decimos que lea el valor del
34 potenciómetro, valor el cual oscila entre 0 y 1023
35 val1= map(val1, 0 ,1023, 0, 180); //Traduce la lectura análga (0, 1023) a
36 grados (0°, 180°)
37 Servopinza.write(val1); //Mueve el Servo según la lectura análoga
38 delay(15);
39
40 ////////////////////////////
44 grados (0°, 180°)
45 Servoderecha.write(val2); //Mueve el Servo según la lectura análoga
46 delay(15);
47
48 /////////////////////
52 grados (0°, 180°)
53 Servoizquierda.write(val3);//Mueve el Servo según la lectura análoga
54 delay(15);
55
56 /////////////////////////
57 val4 = analogRead(potenciometro4); //Aquí le decimos que lea el valor del
59 val4 = map(val4, 0 ,1023, 0, 180); //Traduce la lectura análga (0, 1023)
60 a grados (0°, 180°)
61 Servobase.write(val4); //Mueve el Servo según la lectura análoga
62 delay(15);
63 }
64
RESULTADO
COMENTÁRIOS
157
Aula 28 - Calculadora
CRÉDITOS DA AULA
https://www.tinkercad.com/things/cVI4WnPWonc-aula-28-calculadora-com-display-lcd-e-teclado-4-
x-4/editel
O QUE VAMOS FAZER?

Montar uma calculadora com Arduino.

Nr O Material Qtde
1 Arduino UNO R3 01
2 Protoboard 01
4 Display LCD 16 x 2 01
5 Teclado 4x4 01
7 Potenciômetro 01

158
SCRIPT ARDUINO
2 #include <Keypad.h>
3
4 const byte filas = 4; //quatro filas.
5 const byte columnas = 4; //quatro colunas.
6
7 char tecla[filas][columnas] = {
8 {'1','2','3','A'},
9 {'4','5','6','+'},
10 {'7','8','9','-'},
11 {'*','0','=','/'}
12 };
13
14 byte pinFilas[filas] = {7, 6, 5, 4}; //conectarse à saída de fila do
15 teclado.
16 byte pinColumnas[columnas] = {3, 2, A5, A4}; //conectarse à saída de
17 colunas do teclado.
18
19 Keypad keypad = Keypad(makeKeymap(tecla), pinFilas, pinColumnas, filas,
20 columnas);
21 LiquidCrystal lcd(8,9,10,11,12,13); //RS,E,D4,D5,D6,D7
22 String leeCadena1,leeCadena2;
23 byte cuenta=0;
24
25 char a;
26 long dato1,dato2,rpt1;
27 double dato3,dato4,rpt2;
28
29 void setup(){
30 lcd.begin(16,2); //LCD (16 colunas e 2 filas)
31 }
32
33 void loop(){
34 char key = keypad.getKey();
35 if
36 (key=='0'||key=='1'||key=='2'||key=='3'||key=='4'||key=='5'||key=='6'||k
37 ey=='7'||key=='8'||key=='9'){
38
39 if(cuenta==0){
40 lcd.print(key);
41 leeCadena1+=key;
42 dato1=leeCadena1.toInt();
43 }
44
45 else if(cuenta==1){
46 lcd.print(key);
47 leeCadena2+=key;
48 dato2=leeCadena2.toInt();
49 }
50 }
51
52 if(key=='A'){
53 leeCadena2="";
54 leeCadena1="";
55 dato1=0;
56 dato2=0;
57 dato3=0;
58 dato4=0;
59 cuenta=0;
60 rpt1=0;
159
61 rpt2=0;
62 lcd.clear();
63 }
64
65 else if(key=='='&&a=='+'){
66 cuenta++;
68 rpt1=dato1+dato2;
69 lcd.print("RPT=");
70 lcd.print(rpt1);
71 }
72
73 else if(key=='='&&a=='-'){
74 cuenta++;
76 rpt1=dato1-dato2;
78 lcd.print(rpt1);
79 }
80
81 else if(key=='='&&a=='*'){
82 cuenta++;
84 rpt1=dato1*dato2;
86 lcd.print(rpt1);
87 }
88
89 else if(key=='='&&a=='/'){
90 cuenta++;
92 dato3=dato1;
93 dato4=dato2;
95 rpt2=(dato3/dato4);
96 lcd.print(rpt2);
97 }
98
99 else if((key=='+'||key=='-'||key=='*'||key=='/')&&(cuenta==0)){
100 cuenta++;
101 a=key;
102 lcd.print(a);
103 }
104 }
160
RESULTADO
COMENTÁRIO
161

Curso Básico de Arduino

Enviado por

Direitos autorais:

Formatos disponíveis

Curso Básico de Arduino

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Curso Básico de Arduino

Enviado por

Direitos autorais:

Formatos disponíveis

Curso Básico de Arduino

TÓPICOS AVANÇADOS DE PROGRAMAÇÃO

Marcelo Felipe Moreira Persegona e Luiz Felipe Marcolino Persegona

Curso Básico de Arduino | Brasília/DF, março de 2023

Marcelo Felipe Moreira Persegona é doutor em Política e

Luiz Felipe Marcolino Persegona é estudante do Colégio Militar de Brasília

O Arduino é uma plataforma eletrônica de código aberto baseada em hardware e

Então Arduino é um conjunto de ferramentas para facilitar o desenvolvimento de

• Site oficial do Arduino

• Site emulador de Arduino

• Lojas físicas e virtuais para compra de placa Arduino e componentes

1 Entenda hardware como as placas e software como o programa de computador.

Por exemplo, em um projeto com um servomotor e um potenciômetro no Arduino,

Então, pode-se dizer que o Arduino é um microcontrolador com diversos

Com um Arduino somos capazes de criar uma infinidade de projetos, como

O conjunto formado pelo: Arduino, IDE de programação e linguagem de

Placa Arduino UNO Original da Itália à esquerda e Arduino IDE à direita.

Os programas escritos para o Arduino são chamados de sketch

O método setup() é executado uma vez assim que o Arduino é ligado e

Para começar os projetos com Arduino é necessária uma placa Arduino, um

O que são shields?

Alimentação (USB/Conector P4)

NOTA: geralmente os pinos analógicos do Arduino podem também ser usados

Assim como a Nintendo original, o Arduino possui um botão de reinicialização (9).

Você aprenderá por meio da construção de vários projetos criativos.

1 x Placa de desenvolvimento UNO R3 compatível com Arduino

Aqui será explicado como instalar a IDE do Arduino no sistema operacional

Pimeiro baixe o programa da IDE do Arduino do link abaixo:

Caso necessite de mais ajuda, segue o link das instruções de instalação:

Baixando o programa do Arduino (IDE)

Quando terminar de baixar o arquivo, proceda a instalação e siga os passos

O processo de instalação irá extrair e instalar os arquivos necessários para a

O QUE VAMOS FAZER?

Conhecer o a Placa de Ensaio (Protoboard).

O QUE É A PLACA DE ENSAIO?

No TinkerCad possui três tipos de Placa de Ensaio:

Placa de Ensaio pequena

Placa de Ensaio média

Na superfície de uma matriz de contato há uma base de plástico em que existem

CONHECENDO COMO FUNCIONA UMA PLACA DE ENSAIO

São as faixas de contatos no qual são instalados os componentes

Nas laterais das placas geralmente existem duas trilhas de contatos

As cinco colunas de contatos do lado esquerdo do entalhe são

São usadas para o fornecimento de tensão ao circuito, constituídas de

Alguns projetos modernos de placas de ensaio possuem um controle

Você pode observar na figura, a placa de montagem possui a matriz principal em

O QUE VAMOS FAZER?

Conhecer o ambiente de trabalho do Tinker Cad.

Em 2011 a página tinkercad.com foi lançada como uma ferramenta de modelagem

Em março de 2017 a Autodesk recomendou que os usuários do 123D Sculpt, a

O Autodesk Tinkercad Circuito é uma poderosa ferramenta online para projetar e

O Autodesk Tinkercad Circuito fornece uma interface simples de arrastar e soltar

Além de projetar circuitos, o Tinkercad Circuit também fornece um editor de código

O Autodesk Tinkercad Circuito é uma excelente ferramenta para uso educacional,

Em conclusão, Autodesk Tinkercad Circuito é uma poderosa ferramenta online

COMO FUNCIONA A PLATAFORMA ONLINE DO TINKERCAD?

O QUE VAMOS FAZER?

Fazer piscar um LED com o Arduino.

PEÇAS QUE SERÃO UTILIZADAS