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, outubro de 2019
1
Sumário
O QUE É ARDUINO? ............................................................................................................................. 4
O QUE SÃO SHIELDS? ........................................................................................................................ 6
COMPONENTES DA PLACA ARDUINO ........................................................................................... 6
INSTALANDO A IDE DO ARDUINO NO WINDOWS ..................................................................... 16
Aula 01 - Hello, World! ....................................................................................................................... 18
Aula 02 - LED com botão liga desliga ............................................................................................ 20
Aula 03 - Controlar um LED com um potenciômetro ................................................................. 26
Aula 04 - Botão que acende LED-s com efeito ............................................................................ 32
Aula 05 - Controlando 8 LED-s com CI74HC595 e fazendo contagem binária ................... 39
Aula 06 - Piscar um LED com efeito fader .................................................................................... 44
Aula 07 - Sinal de trânsito ................................................................................................................. 48
Aula 08 - Dois sinais de trânsito sincronizados.......................................................................... 53
Aula 09 - Controlando LED RGB multicolorido ........................................................................... 62
Aula 10 - Controlar as cores de um LED RGB com botões ..................................................... 68
Aula 11 - Sensor de luz LDR com saída de leitura em LED-s .................................................. 76
Aula 12 - Emitir sons com o buzzer ................................................................................................ 80
Aula 13 - Controlando dois servomotores com potenciômetros ........................................... 84
Aula 14 - Controlando um servomotor com potenciômetro .................................................... 87
Aula 15 - Controlar a velocidade de um motor CC com potenciômetro ............................... 90
Aula 16 - Motor CC com controle de velocidade, LED-s medidores de potência e buzzer
para alerta de potência máxima ...................................................................................................... 94
Aula 17 - Alarme com sensor de movimentos PIR ..................................................................... 99
Aula 18 - Display LCD - Hello World ............................................................................................. 102
Aula 19 - Display LCD com dois potenciômetros ..................................................................... 105
Aula 20 - Display LCD com sensor de temperatura e luminosidade ................................... 111
Aula 21 - Display LCD com dois potenciômetros e servomotor controlado com um
potenciômetro .................................................................................................................................... 117
Aula 22 - Relógio simples com display LCD .............................................................................. 122
Aula 23 - Montagem de relógio com módulo DS1302RTC ..................................................... 125
Aula 24 - Sensor de obstáculos ultrassônico HC-SRO4 ......................................................... 130
Aula 25 - Carro robótico com sensor de obstáculo e servomotor ....................................... 135
Aula 26 - Carro robótico controlado com controle remoto infravermelho ........................ 139
Aula 27 - Braço robótico com 4 servomotores controlados com potenciômetros ......... 143
Aula 28 - Calculadora ....................................................................................................................... 150
Aula 29 – Controle Remoto Infravermelho ................................................................................. 154
2
Aula 29 - Hovercraft .......................................................................................................................... 159
Aula 30 - Drone com material reciclado ...................................................................................... 167
Aula 31 – Robô humanoide............................................................................................................. 169
Aula 01 - 17DOF RC Robot.............................................................................................................. 177
Aula 01 – PLOTCLOCK .................................................................................................................... 180
Aula 01 – PS2 Controller Sketch for ESCs and Stuff ............................................................... 194
Aula 01 – Braço robótico com 6 servomotores ......................................................................... 200
Aula 01 – Senha com teclado ......................................................................................................... 212
Aula 01 – Fechadura com senha via teclado ............................................................................. 216
Aula 01 – Mão articulada ................................................................................................................. 222
Aula 01 – Uso de LED-s ................................................................................................................... 244
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.
https://www.tinkercad.com/circuits
https://www.arduino.cc
(Caso necessário, Download do drive USB2.0-Serial CH34x)
https://sparks.gogo.co.nz/ch340.html
https://www.robocore.net/loja/shields-para-arduino
https://www.huinfinito.com.br
http://fritzing.org/download/
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
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
1 Entenda hardware como as placas e software como o programa de computador.
4
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 capaz 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.
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.
5
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.
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.
6
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.
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.
7
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/
14
https://www.instructables.com/id/DoggoBot-Version-1/
https://www.instructables.com/id/Radar-Gr%C3%A1fico-Con-Arduino-Y-Processing/
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
This document explains how to install the Arduino Software (IDE) on Windows
machines
Download the Arduino Software (IDE)
Proceed with board specific instructions
Download the Arduino Software (IDE)
Get the latest version from the download page. You can choose between the Installer (.exe) and the Zip
packages. We suggest you use the first one that installs directly everything you need to use the Arduino
Software (IDE), including the drivers. With the Zip package you need to install the drivers manually. The
Zip file is also useful if you want to create a portable installation.
When the download finishes, proceed with the installation and please allow the driver installation
process when you get a warning from the operating system.
Choose the components to install
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
Choose the installation directory (we suggest to keep the default one)
The process will extract and install all the required files to execute properly the Arduino
Software (IDE)
Proceed with board specific instructions
When the Arduino Software (IDE) is properly installed you can go back to the Getting Started Home
and choose your board from the list on the right of the page.
17
Aula 01 - Hello, World!
O QUE VAMOS FAZER?
Como acender 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 Resitor de 1000 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.
18
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
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
19
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
20
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.
21
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.
22
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.
23
SCRIPT ARDUINO
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.
24
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
25
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?
Controlar um LED com um potenciômetro.

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.
26
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.
27
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.
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).
28
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;
29
• 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.
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);
30
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.
RESULTADO
COMENTÁRIOS
31
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
32
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.
33
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
34
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.
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;
35
• 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
(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.
36
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.
Código fonte comentado do projeto arduino com botão que acende LED-s com efeito.
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() {
37
31 estadoBotao = digitalRead(botao);
32
33 if (estadoBotao == HIGH) {
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
38
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 Resitor de 1k ohms 08
6 LED azul 08
Registrador de deslocamento de
7 01
oito bits 74HC595
39
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.
40
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.
41
SCRIPT ARDUINO
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. Segue
abaixo o código fonte comentado deste projeto.
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 }
42
RESULTADO
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
43
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
44
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.
45
Logo abaixo está o esquema do projeto pisca LED com efeito fader.
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
46
14 int brilho = 0;
15 int fader = 5;
16 boolean acende = true;
17 boolean apaga = false;
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
47
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
48
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.
49
Conecte os fios jumper nas colunas 6, 11 e 16 da protoboard.
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.
50
SCRIPT ARDUINO
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).
51
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
52
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
53
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.
54
Neste projeto vamos contruir um protótipo que faz esse exatamente este controle, simulando dois
sinais de trânsito sincronizados.
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.
55
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.
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.
56
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;
57
58
Para começar a programação conecte o Arduino ao seu computador pelo cabo USB, e no
computador execute a IDE do Arduino.
59
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 }
60
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
61
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
62
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.
63
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.
64
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.
Os fios deverão ser conectados da seguinte forma no arduino:

• fio azul no pino digital 8 do arduino;
• fio verde no pino digital 9 do arduino;
• fio vermelho no pino digital 10 do arduino;
• e fio preto no pino GND.
65
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.
Código fonte do projeto Arduino controlando LED RGB.
1 /*
2 Projeto Arduino controla led RGB.
3 Por Jota
4 ----------------------------------------
6 ----------------------------------------
7 */
8
9 //Declaração das constantes
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 }
66
Após inserir o código fonte do projeto na IDE do Arduino, compile e faça o upload do
programa.
RESULTADO
COMENTÁRIOS
67
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
68
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
69
outro na coluna 38 e os resistores de 150 ohms também deverão ser conectados na
linha horizontal azul (negativa).
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).
70
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;
• 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.
71
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;
• 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.
72
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.
SCRIPT ARDUINO
Segue abaixo o código fonte do projeto.
1
/*
2
Projeto Arduino controla LED RGB com botões.
3
Por Jota
4
----------------------------------------
5
--=<| www.ComoFazerAsCoisas.com.br |>=--
6
----------------------------------------
7
*/
8
9
//Declaração das constantes
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
73
17 const int botaoVermelho = 4; //botaoVermelho refere-se ao pino digital
18 4.
19
20 //Variáveis que conterão os estados dos botões (pressionados ou não).
21 int estadoBotaoAzul;
22 int estadoBotaoVerde;
23 int estadoBotaoVermelho;
24
26 void setup() {
27 //Definindo os pinos digitais (8, 9, 10) como de saída.
31
32 //Definindo os pinos digitais (2, 3, 4) como de entrada.
33 pinMode(botaoAzul,INPUT);
34 pinMode(botaoVerde,INPUT);
35 pinMode(botaoVermelho,INPUT);
36 }
37
39 void loop() {
40
41 //Lendo o estado dos botões pelos pinos digitais.
42 estadoBotaoAzul = digitalRead(botaoAzul);
43 estadoBotaoVerde = digitalRead(botaoVerde);
44 estadoBotaoVermelho = digitalRead(botaoVermelho);
45
46 //Acendendo o led RGB conforme os botões pressionados.
47 //Tratando a cor azul
48 if (estadoBotaoAzul == HIGH) {
50 } else {
52 }
53
54 //Tratando a cor verde
55 if (estadoBotaoVerde == HIGH) {
57 } else {
59 }
60
61 //Tratando a cor vermelha
62 if (estadoBotaoVermelho == HIGH) {
64 } else {
66 }
67 }
Após inserir o código fonte na IDE do Arduino compile e faça o upload.
74
RESULTADO
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
75
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
8 Resitor de 10k ohms 01
Sensor de luz LDR (Light
10 Dependent Resistor), ou seja, 01
fotoresistor
76
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.
77
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.
78
31 int valorSensor = analogRead(sensor);
32
33
34 //Valores da luminosidade podem ser alterados conforme necessidade.
35
36 //Luminosidade baixa.
37 if (valorSensor < 300) {
38 apagaLeds();
40 }
41
42 //Luminosidade média.
43 if (valorSensor >= 300 && valorSensor <= 800) {
44 apagaLeds();
46 }
47
48 //Luminosidade alta.
49 if (valorSensor > 800) {
50 apagaLeds();
52 }
53
54 //Exibindo o valor do sensor no serial monitor.
55 Serial.println(valorSensor);
56
57 delay(50);
58 }
59
60 //Função criada para apagar todos os LED-s de uma vez.
61 void apagaLeds() {
65 }
RESULTADO
Segue abaixo o esquema detalhado do projeto Arduino com sensor de luz LDR com
saída de leitura em LED-s.
COMENTÁRIOS
79
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
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
80
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.
81
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 }
82
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
83
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
84
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 }
85
RESULTADO
COMENTÁRIOS
86
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.
87
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
24 void setup() {
25 //associando o pino digital ao objeto da classe Servo
88
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
89
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
90
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.
91
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 }
92
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
93
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 e 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
13 Resistor de 100 ohms 03
94
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.
95
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.
96
55 analogWrite(transistor, valPotenciometro);
56
57 //acendendo e pagando leds conforme posição do
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 }
RESULTADO
97
COMENTÁRIOS
98
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
6 Resistor de 220 ohms 02
7 Buzzer de 5 volts 01
8 Bateria de 9 volts 01
Suporte para bateria com plug
9 01
para ligar no Arduino
99
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
100
32 //Verificando se ocorreu detecção de movimentos
33 if (valorSensorPIR == 1) {
34 ligarAlarme();
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
101
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
4 Resistor de 10k ohms 02
Display LCD do tipo JHD 162A de
5 01
16 colunas e 2 linhas
102
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 }
103
RESULTADO
COMENTÁRIOS
104
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
105
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.
106
A imagem abaixo mostra o verso do display LCD JHD 162A. No canto inferior direito vemos o código
deste display.
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.
107
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.
108
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 }
109
RESULTADO
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
110
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)
7 Resistor de 10k ohms 01
111
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.
112
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.
113
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.
114
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
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
115
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
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
116
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
117
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.

118
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.
119
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 }
120
RESULTADO
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
121
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
122
SCRIPT ARDUINO

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);
123
64 }
65
66 lcd.setCursor(9, 1); lcd.print(yer);
67
68 delay(1000);
69 // lcd.clear();
70 }
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
124
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:
125
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.
126
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
127
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.
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 }
128
RESULTADO
COMENTÁRIOS
129
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)
130
Nr O Material Qtde
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.
131
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);
132
24
25 // Lê a porta digital Echo e retorna o tempo da onda de som em
26 microssegundos
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 }
133
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
134
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
135
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;
136
55 }
56
57 void goForward()
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);
137
select = pos;
pos+=45;
if(pos == 225)
pos = 0;
distance=getDistance();
}
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
138
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
139
18 void setup(){
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");
140
81
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 }
141
RESULTADO
COMENTÁRIOS
142
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
143
144
145
146
147
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
148
27 Servoizquierda.attach(11); //El pin al cual conectaremos nuestro Servo
28 IZQUIERDA
29 Servobase.attach(10); //El pin al cual conectaremos nuestro Servo BASE
30 }
31
32 void loop()
33 {
34 val1= analogRead(potenciometro1); //Aquí le decimos que lea el valor del
35 potenciómetro, valor el cual oscila entre 0 y 1023
36 val1= map(val1, 0 ,1023, 0, 180); //Traduce la lectura análga (0, 1023) a
37 grados (0°, 180°)
38 Servopinza.write(val1); //Mueve el Servo según la lectura análoga
39 delay(15);
40
41 ////////////////////////////
45 grados (0°, 180°)
46 Servoderecha.write(val2); //Mueve el Servo según la lectura análoga
47 delay(15);
48
49 /////////////////////
53 grados (0°, 180°)
54 Servoizquierda.write(val3);//Mueve el Servo según la lectura análoga
55 delay(15);
56
57 /////////////////////////
58 val4 = analogRead(potenciometro4); //Aquí le decimos que lea el valor del
60 val4 = map(val4, 0 ,1023, 0, 180); //Traduce la lectura análga (0, 1023)
61 a grados (0°, 180°)
62 Servobase.write(val4); //Mueve el Servo según la lectura análoga
63 delay(15);
64 }
RESULTADO
COMENTÁRIOS
149
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

150
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;
151
56 dato2=0;
57 dato3=0;
58 dato4=0;
59 cuenta=0;
60 rpt1=0;
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 }
152
RESULTADO
COMENTÁRIO
153
Aula 29 – Controle Remoto Infravermelho
CRÉDITOS DA AULA
O QUE VAMOS FAZER?

.
SCRIPT ARDUINO
Captura de teclas do Controle Remoto
#include <IRremote.h> //INCLUSÃO DE BIBLIOTECA
int RECV_PIN = 2; //PINO DIGITAL UTILIZADO PELO FOTORRECEPTOR KY-022
IRrecv irrecv(RECV_PIN); //PASSA O PARÂMETRO PARA A FUNÇÃO irrecv
decode_results results; //VARIÁVEL QUE ARMAZENA OS RESULTADOS (SINAL IR

RECEBIDO)
void setup(){
Serial.begin(9600); //INICIALIZA A SERIAL
irrecv.enableIRIn(); //INICIALIZA A RECEPÇÃO DE SINAIS IR
}
154
void loop(){
//CAPTURA O SINAL IR
if (irrecv.decode(&results)) {
Serial.print("Código HEX: "); //IMPRIME O TEXTO NO MONITOR SERIAL
Serial.println(results.value, HEX); //IMPRIME NO MONITOR SERIAL O CÓDIGO IR
EM FORMATO HEXADECIMAL
Serial.print("Código DEC: "); //IMPRIME O TEXTO NO MONITOR SERIAL
Serial.println(results.value); //IMPRIME NO MONITOR SERIAL O CÓDIGO IR EM
FORMATO DECIMAL
Serial.println(""); //QUEBRA DE LINHA NA SERIAL
irrecv.resume(); //AGUARDA O RECEBIMENTO DE UM NOVO SINAL IR
}
delay(100); //INTERVALO DE 100 MILISSEGUNDOS
}
Programação do Controle Remoto
#include <IRremote.h> //INCLUSÃO DE BIBLIOTECA
int RECV_PIN = 2; //PINO DIGITAL UTILIZADO PELO FOTORRECEPTOR KY-022
IRrecv irrecv(RECV_PIN); //PASSA O PARÂMETRO PARA A FUNÇÃO irrecv
const int ledVermelho = 8; //PINO DIGITAL UTILIZADO PELO LED VERMELHO

const int ledVerde = 9; //PINO DIGITAL UTILIZADO PELO LED VERDE
const int ledAmarelo = 10; //PINO DIGITAL UTILIZADO PELO LED AMARELO
long int codTecla1 = 16724175; //CÓDIGO DA TECLA 1 (ALTERE PARA O CÓDIGO

DECIMAL QUE VOCÊ CAPTUROU)
155
int stLedVermelho = 0; //VARIÁVEL QUE CONTROLA O ESTADO DO LED

VERMELHO (LIGADO / DESLIGADO)
int stLedVerde = 0; //VARIÁVEL QUE CONTROLA O ESTADO DO LED VERDE
(LIGADO / DESLIGADO)
int stLedAmarelo = 0; //VARIÁVEL QUE CONTROLA O ESTADO DO LED AMARELO
(LIGADO / DESLIGADO)
decode_results results; //VARIÁVEL QUE ARMAZENA OS RESULTADOS (SINAL IR

RECEBIDO)
void setup(){
irrecv.enableIRIn(); //INICIALIZA A RECEPÇÃO DE SINAIS IR
pinMode(ledVermelho, OUTPUT); //DEFINE O PINO COMO SAÍDA
pinMode(ledVerde, OUTPUT); //DEFINE O PINO COMO SAÍDA
pinMode(ledAmarelo, OUTPUT); //DEFINE O PINO COMO SAÍDA
}
void loop() {
//CAPTURA O SINAL IR
if (irrecv.decode(&results)) {
if((results.value == codTecla1) && (stLedVermelho == 0)){ //SE O CÓDIGO IR
CAPTURADO FOR IGUAL A codTecla1 E A
//VARIÁVEL stLedVermelho FOR IGUAL A 0, FAZ
digitalWrite(ledVermelho, HIGH); //LIGA O LED VERMELHO
stLedVermelho = 1; //VARIÁVEL RECEBE O VALOR 1
}else{//SENÃO, FAZ
if((results.value == codTecla1) && (stLedVermelho == 1)){ ///SE O CÓDIGO IR
//VARIÁVEL stLedVermelho FOR IGUAL A 1, FAZ
digitalWrite(ledVermelho, LOW); //DESLIGA O LED VERMELHO
156
stLedVermelho = 0; //VARIÁVEL RECEBE O VALOR 0
}
}
if((results.value == codTecla2) && (stLedVerde == 0)){ //SE O CÓDIGO IR

//VARIÁVEL stLedVerde FOR IGUAL A 0, FAZ
digitalWrite(ledVerde, HIGH); //LIGA O LED VERDE
stLedVerde = 1; //VARIÁVEL RECEBE O VALOR 1
}else{//SENÃO, FAZ
if((results.value == codTecla2) && (stLedVerde == 1)){ ///SE O CÓDIGO IR
//VARIÁVEL stLedVerde FOR IGUAL A 1, FAZ
digitalWrite(ledVerde, LOW); //DESLIGA O LED VERDE
stLedVerde = 0; //VARIÁVEL RECEBE O VALOR 0
}
}
if((results.value == codTecla3) && (stLedAmarelo == 0)){ //SE O CÓDIGO IR

//VARIÁVEL stLedAmarelo FOR IGUAL A 0, FAZ
digitalWrite(ledAmarelo, HIGH); //LIGA O LED AMARELO
stLedAmarelo = 1; //VARIÁVEL RECEBE O VALOR 1
}else{//SENÃO, FAZ
if((results.value == codTecla3) && (stLedAmarelo == 1)){ ///SE O CÓDIGO IR
//VARIÁVEL stLedAmarelo FOR IGUAL A 1, FAZ
digitalWrite(ledAmarelo, LOW); //DESLIGA O LED AMARELO
stLedAmarelo = 0; //VARIÁVEL RECEBE O VALOR 0
}
}
irrecv.resume(); //AGUARDA O RECEBIMENTO DE UM NOVO SINAL IR
157
}
delay(10); //INTERVALO DE 10 MILISSEGUNDOS
}
RESULTADO
COMENTÁRIOS
158
Aula 29 - Hovercraft
CRÉDITOS DA AULA
https://www.instructables.com/id/EAL-Arduino-Hovercraft/
O QUE VAMOS FAZER?
Construir um hovercraft controlado por Arduino.
1. A parte da base do hovercraft é feita de flamingo. Usamos um grande quadrado, que

cortamos nas dimensões desejadas e fizemos a circular de front-end.
2. 2x motores DC, para girar a propulsão e o ventilador.
3. Um driver de motor de passo
4. Um quadro, para segurar os motores. Para o nosso hovercraft, fizemos a moldura de

madeira e acrílico.
5. Um módulo bluetooth, para controlar o hovercraft. Nós usamos um módulo Bluetooth

HC-05.
6. Placa Arduino, breadboard, fios, baterias de 9v e um adaptador de 12v. Nós usamos

o Arduino Mega 2560.
7. Hélice + ventilador. Nós baixamos nossa hélice do Thingiverse e a imprimimos em

nossa escola (http://www.thingiverse.com/thing:1733112). Usamos a mesma hélice
como propulsor e ventilador, mas removemos o círculo externo do ventilador.
159
PASSOS DA MONTAGEM
Construindo o barco
No centro da base, cortamos um buraco para o ventilador, que vai levitar o hovercraft.
No fundo, nós enrolamos em um saco plástico, e colocamos vários pequenos orifícios

nele, para fazer o ar passar, e fazer o hovercraft levitar
Em seguida, usamos fita adesiva para proteger o saco de plástico e para garantir que
o flamingo não se dissolve em pequenos pedaços.
O quadro foi então colocado em cima do hovercraft e mantido junto com cola. Na parte
superior da estrutura, e acima do furo, há uma placa de acrílico para montagem dos
motores.
O propulsor / ventilador é colado nos motores e nos motores e colado nas placas de
acrílico.
160
161
Passo 3: A parte mecânica
A primeira parte é ligar o Arduino. Usamos 1 bateria de 9v para alimentar o Arduino,

pelo adaptador de 12v
Em seguida, conectamos o driver do motor ao Arduino para fixar o pino 3 + 4 para a
propulsão e o pino 8 + 9 para o ventilador.
Em seguida, ligamos os motores ao acionador do motor. O driver do motor também é
ligado à terra, e a 3 baterias conectadas em paralelo de 9v, elas ligam os motores.
Em seguida, conectamos o módulo bluetooth ao Arduino, por uma placa de montagem,
porque precisamos ter resistências entre eles.
Etapa 4: Software
162
Para controlar o hovercraft, usamos o bluetooth e controlamos o hovercraft em nosso
smartphone.
Para fazer o aplicativo para o nosso smartphone, usamos o programa on-line gratuito,
MIT App Inventor (http://appinventor.mit.edu). Do nosso telefone, agora podemos
fazer o hovercraft avançar, retroceder e parar.
163
Etapa 5: Melhorias
Em primeiro lugar, deveríamos ter motores mais rápidos, para que o hovercraft tivesse mais
potência e levitasse mais facilmente.
Deveríamos ter tornado o corpo mais magro, por isso seu peso é reduzido.
Para fazer o hovercraft dirigir, você precisa de um módulo que possa empurrar e arrastar e
uma nadadeira para dirigir. Infelizmente, nós nunca recebemos o módulo que pedimos, então
não conseguimos fazer o hovercraft dirigir.
Sensores, consideramos colocar sensores na frente do hovercraft, para que ele parasse
quando chegasse perto de um objeto. Nós não conseguimos fazer isso, porque nos deparamos
com tantos problemas que simplesmente não tivemos tempo.
164
SCRIPT ARDUINO
1 */
2
3 int motor1Pin1 = 3; // Makes the hovercraft go forward
4 int motor1Pin2 = 4; // Makes the hovercraft go backwardint motor2Pin1 = 8;
5 // Turns on the fan
6 int motor2Pin2 = 9; //int state;
7 int flag=0; //makes sure that the serial only prints the state once
8 int stateStop=0;
9 void setup() {
10 // sets the pins as outputs
11 pinMode(motor1Pin1, OUTPUT);
12 pinMode(motor1Pin2, OUTPUT); pinMode(motor2Pin1, OUTPUT);
13 pinMode(motor2Pin2, OUTPUT); // initialize serial communication at
14 9600 bits per second
16 }
17 void loop() {
18 //if some data is sent, reads it and saves in state
19 if(Serial.available() > 0){
20 state = Serial.read();
21 flag=0;
22 }
23 // if the state is 'F' the Hovercraft will go forward
24 if (state == 'F') {
25 digitalWrite(motor1Pin1, HIGH);
26 digitalWrite(motor1Pin2, LOW);
29 if(flag == 0){
30 Serial.println("Go Forward!");
31 flag=1;
32 }
33 }
34
35 // if the state is 'S' the hovercraft will turn off
36 else if (state == 'S' || stateStop == 1) {
41 if(flag == 0){
42 Serial.println("STOP!");
43 flag=1;
44 }
45 stateStop=0;
46 } // if the state is 'B' the hovercraft will go backwards
47 else if (state == 'B') {
52 if(flag == 0){
53 Serial.println("Reverse!");
54 flag=1;
55 }
56 }
57 }
165
RESULTADO
COMENTÁRIOS
166
Aula 30 - Drone com material reciclado
CRÉDITOS DA AULA
https://hackaday.com/2014/04/01/e-waste-quadcopter-lifts-your-spirits-while-keeping-costs-
down/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed:+hackaday/LgoM+(Hack+
a+Day)
O QUE VAMOS FAZER?

Montar um drone com material reciclado.
The advancement of Quadcopters and their capabilities over the last few years has been amazing.
Unfortunately, the price point to get into the sport with a decent size, non-toy, vehicle is still
several hundred dollars. And what’s the fun with buying one when you can built it?!? Strapped
for cash and feeling the same way, [Hans] over at the hackerspace Knackatory decided to build
a quadcopter from e-waste.
The + shaped frame is made from lightweight plywood. It’s pretty obvious that the main rotors
are PC Fans, 140mm in this case. Normally, these wouldn’t be able to create enough lift to get
out of their own way except the on-board 24v Dewalt cordless tool battery bumps up the fan
speed to 15,000 rpm. The one orange fan allows the operator to maintain a visual reference to
which side of the ‘copter is forward.
An Arduino running MultiWii control software is the brains of this UAV. The MultiWii software
uses the sensors from part of a Nintendo Wii remote to sense orientation and movement. While
there is no hand held transmitter with this quadcopter per se, communication to the host computer
is handled by a wireless router running OpenWRT. The router is the gateway that allows the
Arduino and Ethernet Shield combination to communicate through the Hackerspace’s wifi
network. Flight plans are pre-programmed. Admittedly, the real time control through computer
keyboard commands needs a little work. The team plans on interfacing a regular USB game
controller with the software.
Making stuff out of e-waste is a great way to recycle. Remember this e-waste 3D Printer?
167
SCRIPT ARDUINO
RESULTADO
COMENTÁRIOS
168
Aula 31 – Robô humanoide
CRÉDITOS DA AULA
O QUE VAMOS FAZER?

.
17DOF Robô-Alma H3.0 Bípede RobtichumanóideRobot de Alumínio Full Frame Kit

w/17 pcs Servo + Controlador
nota: não é só branco ou vermelho. por favor entre em contato conosco antes de fazer
um pedido.
descrição:
-isso inclui uma cabeça de robô, um corpo principal, dois braços, duas pernas, use
poder servo digital. este robô pode terminar a pé, agachamento, transformando, slide
lateral movimentos, e pode dançar, combate a incêndios, ou movimentos mais
complicados. se com sensores relacionados, pode subir escadas, linhas de
rastreamento, etc
especificações:
-altura: 365mm
-peso: 1650g
-articulações: 17 juntas
-estrutura: 1mm liga de alumínio strucutre, o peso leve e de alta resistência

-Servo: servo digital, alto torque, alta precisão
-controlador: controlador do robô, com sobrecarga, alarme de baixa tensão
instalação de Download: clique aqui pls contato obter senha
Pacote inclui:
-robô de metal frame set x 1
-17 PCS Servos (13 PCS LDX-218; 4 PCS LDX-227)
169
-15 cm cabo de extensão servo x 2 pcs
-tensão step down módulo x 1

-controlador de Servo x 1
-PS2 controle remoto x 1
-cabo USB x 1
-Charger x 1
-prendedor de cabo x 20
170
171
172
173
174
175
SCRIPT ARDUINO
RESULTADO
COMENTÁRIOS
176
Aula 01 - 17DOF RC Robot
CRÉDITOS DA AULA
https://www.banggood.com/DIY-17DOF-RC-Dancing-Robot-Educational-Walking-Race-Robot-Kit-
p-
1428681.html?gmcCountry=NZ&createTmp=1&utm_source=google&utm_medium=cpc_ods&utm_
content=nancy&utm_campaign=cdm-cart-all-
nancy&gclid=Cj0KCQjw_r3nBRDxARIsAJljleFGWxoqkDk9udK7_rFZY9WJAFSfZXLiJXwWRxG6fR
lH4VeqsaCP2LgaAmFqEALw_wcB&ID=224&cur_warehouse=CN
O QUE VAMOS FAZER?

.
Description:
Product: 17DOF RC Robot
Materials: Metal
Servo:
MG996R Servos
MG995 Servos(others)
- Color: Black
- Size:40cm(H)*23cm(W)
Features:
- Arches punching, corner cutting
- Cost-effective and easy-to-use
- For hobbyists, robot competition, kids
- Humanoid robot
Containing the 17DOF:
1DOF of the head
4DOF of the arm
2DOF of the shoulder
177
2DOF of the hip
6DOF of the legs
2DOF of the feet
Note: the servos are not included
Package includes:
- 16 x Multi-functional servo bracket
- 7 x Short U-type servo bracket
- 4 x Long U-type servo bracket
- 4 x Oblique U-type servo bracket
- 4 x one-type servo bracket
- 4 x L-type servo bracket
- 1 x U-type robot waist bracket
- 2 x Foot Base
- 14 x Miniature Ball Radial Bearing
- 1 x Screw and screw cap set
SCRIPT ARDUINO
RESULTADO
178
COMENTÁRIOS
179
Aula 01 – PLOTCLOCK
CRÉDITOS DA AULA
O QUE VAMOS FAZER?

.
180
181
Installation instructions
182
183
184
185
186
Summary
A clock that plots time. Designed with makeability in a fablab/makerspace/hackerspace in mind.
You need:
187
Laser cutter or 3D printer
1 Arduino
3 servos
1 dry wipe pen
M3 nuts, bolts, thread tap
Update to V1.01:
added calibration routine and documentation to Arduino code
see the instruction tab above for building instructions
http://wiki.fablab-nuernberg.de/w/Ding:Plotclock(german)
http://www.youtube.com/watch?v=iOLFP90DneY
https://github.com/9a/plotclock(not maintained!)
Instructions
Update 08/15: You might want to take a look at

http://www.thingiverse.com/thing:931498/#instructions for a more detailed documentation
Update 10/15: You should also check out http://www.instructables.com/id/Plot-Clock-for-

dummies/?ALLSTEPS Thanks to Kjetil Egeland!
Materials I used:
Arduino UNO
Tower Pro 9g servos (those cheap ones from ebay)
WB SL DRYWIPE MARKER, bullet tip
A small custom servo adapter, there are shields or servo- Arduino that also can be used. You can also
just use jumper wires: 5V to red servo wire, GND to brown or black servo wire and the Arduino servopins
connected to the yellow or orange servo wire
188
Building instructions:
(for version 1.01!)
1.Lasercut plotclock_beta1.pdf from 3mm material or 3D print plotclock_SUP7.skp
the black areas in the pdf on the servo arms should be used to engrave some material away, so the
servohorns settle in
use http://www.thingiverse.com/thing:250204 for single STL files if you 3D print the clock (Thanks
corben33!)
2.3D print swee.stl or reuse some other cylindrical part for the sweeper
3.Tap 2.5mm holes with M3 thread
4.Assemble arms with M3 screws, gently adjust the counternuts so that the joints under the screw heads
just have enough play for smooth movement (see joint picture).
5.load Arduino sketch plotclock_V1, see code comments for further information
http://playground.arduino.cc/Code/time library is needed
6.Add some sort of cloth with double sided tape to sweeper
7.Attach servos to digital pin 2, 3 and 4, according to Arduino sketch, test them without anything
attached by plugging in the Arduino (the photos show it being connected to 1, 2 and 3, which isn't
optimal since 1 is also the TX pin, so during Arduino startup the lifting servo jumps around)
8.Put everything together
You may have to redrill the holes that are used for securing the servos, since some servo screws are a
tight fit.
Acrylic is brittle and easily breaks wen the mounting holes are to small. Only push the servo arms onto
their hubs, don't secure them with screws! For initial calibration do not mount the resting clip for the
wiper (danger of collision with the pen). Glue or screw the servo arms to the acrylic parts.
9.When attaching the servo arms, make sure they can turn enough to reach every point on the drawing
surface by manually turning them
10.Power the Arduino, it should start a calibration cycle where every second the position of both servos
changes by rotating exactly 90 degrees (see last image in gallery)
11.Change the SERVOFAKTOR, SERVOLEFTNULL and SERVORIGHTNULL values until everything matches
up (see code for more information)
12.Attach the pen and the sweeper holder only after testing everything else
189
190
191
SCRIPT ARDUINO
192
RESULTADO
COMENTÁRIOS
193
Aula 01 – PS2 Controller Sketch for ESCs and Stuff
CRÉDITOS DA AULA
http://www.techmonkeybusiness.com/ps2-controller-sketch-for-escs-and-stuff.html
O QUE VAMOS FAZER?
The ideal controller for this ROV is a wired Playstation 2 controller. Luckily they are still made and
there is a library for the Arduino to talk to them. It is also possible to buy sockets for the Playstation
2 controller to plug into without having to make any modifications to the controller.
This sketch is a development to test the use of the wired Playstation 2 controller for driving a series
of servos and LED-s. The Servos are stand-ins for the ESCs that would be used in reality. The LED-
s are used to simulate camera triggers and status as well as pretend to be the main lights.
A more detailed article on using Playstation2 Controllers for Arduino projects is available on the
"Using A Playstation 2 Controller with your Arduino Project"page.
The sketch has been set up for easy splitting into the two sections; one for the Top-Side master
Arduino and one for the ROV Slave Arduino with a series of variables being sent between the two to
carry the control commands.
In this case an Arduino UNO has been used.
The coding makes use of the PS2X library developed by Bill Porter. See www.billporter.info for the
latest from Bill Porter and to download the library. The example sketch with the library gives an
excellent demonstration of the many different ways of interacting with the controller and many
functions that I was unaware existed.
The needs for this project with regards to reading the PS2 controller are fairly simple compared to
what input methods are available. I have made use of;
* the .Button() function which registers when a button is pressed and held. This is useful for the
camera pitch control.
* the .ButtonPressed() function which just registers when the button is pressed but does not
recognise when it is held. This is useful for the toggle functions such as the camera recording on/off,
the main headlights ON/OFF, and the take-a-photo button.
* the .Analog() function which is simply for reading the analogue sticks.
The names Bill Porter has given for all of the buttons and sticks are very logical and the example
sketch with his PSX library makes use of them all. The diagram below identifies the labels used by
the PS2X library.
PS2 Button IDs in the PSX library
There is a variation of the above with “PSAB” substituted for the “PSB” for some of the buttons that
allow the user to get input from how hard the buttons are pressed. For example PSAB_BLUE
194
measures the amount of pressure applied to the X-button. This is very cool but not necessary for the
needs of this project.
The Pin Assignments
3.3V output to PS2 red Pin
5V output to 1kΩ pull up resistors for PS2.
Pin D10 to PS2 yellow pin
Pin D11 to PS2 orange pin
Pin D12 to PS2 brown pin
Pin D13 to PS2 blue pin
Pin D2 to LED Camera Photo Trigger
Pin D3 to LED Camera Record Indicator
Pin D4 to LED Main Lights
Pin D5 to Servo Up Left
Pin D6 to Servo Up right
Pin D7 to Servo Horiz Left
Pin D8 to Servo Horiz Right
Pin D9 to Servo Cam Pitch
External 5V power supply is providing to the Servo Voltage Line
Controls for the ROV
The controls for the ROV will be
Left Stick: X-axis = Roll, Y-axis = Up/down
Right Stick: X-axis = Yaw, Y-axis = forward/back
Direction button pad left = LED Main lights On/Off toggle
195
Direction button pad up = Turn camera upwards
Direction button pad down = Turn camera downwards
Triangle = Start/Stop video recording
Circle = Take photo
Circuit
PS2 Controller, Arduino, and Servo Circuit.
SCRIPT ARDUINO
The sketch below can be downloaded from here: ROVPS2ControlTest1.ino
You can also download the PS2X library from the following webpage: A Collection of
Arduino Libraries Used in This Project.
1 /*
2 ROVPS2ControlTest1.ino
3
4 This development sketch seeks to simulate the Playstation 2 control
5 of the ESCs and servos of the ROV. LED-s are used to stand in for
6 the main LED, the Camera recording function and photographing trigger.
7
8 Pin assignments are:
9
10 3.3V output to PS2 red Pin
11 5V output to 1Kohm pull up resistors for PS2.
12 Pin D10 to PS2 yellow pin
13 Pin D11 to PS2 orange pin
14 Pin D12 to PS2 brown pin
15 Pin D13 to PS2 blue pin
16
17 Pin D2 to LED Camera Photo Trigger
18 Pin D3 to LED Camera Record Indicator
19 Pin D4 to LED Main Lights
20
21 Pin D5 to Servo Up Left
22 Pin D6 to Servo Up right
196
23 Pin D7 to Servo Horiz Left
24 Pin D8 to Servo Horiz Right
25 Pin D9 to Servo Cam Pitch
26
27 External 5V powersupply is providing to the Servo Voltage Line
28
29 The coding pulls on the PS2X library developed by Bill Porter.
30 See www.billporter.info for the latest from Bill Porter and to
31 download the library.
32
33 While the readings from the controller could be plopped straight into
34 the servo commands, variable will be used to hold the values so
35 that it will simulate the data packages that will be sent to the
36 ROV Arduino over the serial eventually.
37
38 The controls for the ROV will be
39 Left Stick - X-axis = Roll, Y-axis = Up/down
40 Right Stick - X-axis = Yaw, Y-axis = forward/back
41 Direction button pad left = LED Main lights On/Off toggle
42 Direction button pad up = turn camera upwards
43 Direction button pad down = turn camera downwards
44 Triangle = Start/Stop video recording
45 Circle = Take photo
46
47 */
48
49 #include <Servo.h> //For driving the ESCs and Servos
50 #include <PS2X_lib.h> // Bill Porter's PS2X Library
51
52 PS2X ps2x; //The PS2 Controller Class
53 Servo UpLServo; //Create servo object representing up left ESC
54 Servo UpRServo; //Create servo object representing up right ESC
55 Servo HorizLServo; //Create servo object representing horiz left ESC
56 Servo HorizRServo; //Create servo object representing horiz right ESC
57 Servo CamServo; //Create servo object representing camera pitch
58
59 const int grnLEDpin = 4; //green LED is on Digital pin 12
60 const int redLEDpin = 3; //red LED is on Digital pin 13.
61 const int yelLEDpin = 2; //yellow LED is on Digital pin 2
62
63 volatile boolean CamRec; //Camera record function toggle
64 volatile boolean LEDHdlts; //LED headlights on/off toggle
65
66 int ForwardVal = 0; //Value read off the PS2 Right Stick up/down.
67 int YawLeftVal = 0; //Value read off the PS2 Right Stick left/right
68 int UpVal = 0; //Value read off the PS2 Left Stick up/down
69 int RollLeftVal = 0; // Value read off the PS2 Left Stick left/right
70 int CamPitch = 90; //Angle of the camera servo.
71
72 int CamPhotoInd = 0; // a counter for controlling the camera trigger indicator
73
74 int upLraw = 0; //Variables to carry the actual raw data for the ESCs
75 int upRraw = 0;
76 int HLraw = 0;
77 int HRraw = 0;
78
79 void setup()
80 {
81 ps2x.config_gamepad(13,11,10,12, false, false);
82 //setup pins and settings: GamePad(clock, command, attention, data, Pressures?,
83 Rumble?)
84 //We have disabled the pressure sensitivity and rumble in this instance and
85 //we know the controller type so we have not bothered with the error checks
86 pinMode(grnLEDpin, OUTPUT); //Sets the grnLEDpin to output
87 pinMode(redLEDpin, OUTPUT); //Sets the redLEDpin to output
88 pinMode(yelLEDpin, OUTPUT); //Sets the yelLEDpin to output.
89 CamRec = false; //Sets the Camera default to not recording
90 UpLServo.attach(5);// attaches the Up left Servo to pin 5
197
UpRServo.attach(6);// attaches the Up Right Servo to pin 6
HorizLServo.attach(7);// attaches the Horizontal Left Servo to pin 7
HorizRServo.attach(8);// attaches the Horizontal Right Servo to pin 8
CamServo.attach(9); // Attaches the Camera Pitch Servo to pin 9.
void loop()
{
ps2x.read_gamepad(); //This needs to be called at least once a second
// to get data from the controller.
if(ps2x.Button(PSB_PAD_UP)) //Pressed and held
{
CamPitch = CamPitch + 1; //increase the camera pitch
}
if(ps2x.ButtonPressed(PSB_PAD_LEFT)) //Pressed
{
LEDHdlts = !LEDHdlts; //Toggle the LED light flag
}
if(ps2x.Button(PSB_PAD_DOWN)) //Pressed and Held

{
CamPitch = CamPitch - 1; //increase the camera pitch
}
if(ps2x.ButtonPressed(PSB_GREEN)) //Triangle pressed

{
CamRec = !CamRec; //Toggle the Camera recording Status
}
if(ps2x.ButtonPressed(PSB_RED)) //Circle pressed

{
CamPhotoInd = 70; //Set to indicate photo taken for about 1 second.
}
//Analogue Stick readings

ForwardVal = ps2x.Analog(PSS_RY);
YawLeftVal = ps2x.Analog(PSS_RX);
UpVal = ps2x.Analog(PSS_LY);
RollLeftVal = ps2x.Analog(PSS_LX);
//Translate the Stick readings to servo instructions

//This would normally happen in the ROV based on the
//Stick readings sent to it from the topside Arduino
//Over the serial.
//Readings from PS2 Controller Sticks are from 0 to 255
//with the neutral being 128. The zero positions are to
//the left for X-axis movements and up for Y-axis movements.
//Variables to carry the actual raw data for the ESCs

upLraw = (128-UpVal)+(128-RollLeftVal)/2; //This will be up to a value of 192
upRraw = (128-UpVal)-(128-RollLeftVal)/2; //This will be up to a value of 192
HLraw = (128-ForwardVal)+(128-YawLeftVal); //This will be up to a value of 256
HRraw = (128-ForwardVal)-(128-YawLeftVal); //This will be up to a value of 256
//Scale the values to be suitable for ESCs and Servos

upLraw=map(upLraw,-193,193,0,179);
upRraw=map(upRraw,-193,198,0,179);
HLraw=map(HLraw,-256,256,0,179);
HRraw=map(HRraw,-256,256,0,179);
//Write it to the Servos or ESCs
UpLServo.write(upLraw);
UpRServo.write(upRraw);
198
HorizLServo.write(HLraw);
HorizRServo.write(HRraw);
// Signalling that a photo has been taken.
if(CamPhotoInd >= 1)
{
CamPhotoInd = CamPhotoInd - 1; //countdown for the CamIndicator
digitalWrite(grnLEDpin,HIGH); //Light the Green LED to indicate
phototriggered
}
if(CamPhotoInd <= 0)
{
digitalWrite(grnLEDpin,LOW); //Photo event indication over.
}
CamPitch = constrain(CamPitch,30,149); //keep CamPitch within the 30 - 149

boundary
CamServo.write(CamPitch); //Move the camera servo
digitalWrite(redLEDpin,CamRec); //Light the redLED based on camera recording
status flag
digitalWrite(yelLEDpin,LEDHdlts); //Light the LED based on headlights status
flag
delay(15);
}
RESULTADO
COMENTÁRIOS
199
Aula 01 – Braço robótico com 6 servomotores
CRÉDITOS DA AULA
https://mauriciodgsantos.wixsite.com/easyds/armds5
O QUE VAMOS FAZER?

.
1 Arduino UNO
6 Potenciômetros Giratórios de 10 KOhm
6 Knobs para Potenciômetros Giratórios
2 Push Buttons Grandes
3 LED-s de 3mm (1 Vermelho, 1 Amarelo e 1 Verde)
3 Resistores de 220 Ohms
1 Fonte de 5V 5A
1 Capacitor Eletrolítico 4700uF - 10v ou 16v
Jumpers
200
SCRIPT ARDUINO
#include <VarSpeedServo.h>
#include <EEPROM.h>
#define espacoMemoria 199

#define tempoPausaEntreMovimentos 500 //configura o tempo de pausa entre cada
movimento
#define pinServo1 13
#define pinServo5 9
#define pinServo6 8
#define pinBotao1 3
#define pinBotao2 2
#define pinLedA 5
#define pinLedB 4
#define pinPot1 A5
#define pinPot2 A4
#define pinPot3 A3
#define pinPot4 A0
#define pinPot5 A1
#define pinPot6 A2
VarSpeedServo servo1;
201
byte pinBotao1Modo();
bool pinBotao2Retencao();
void pinLedAPisca(bool reset = false);
void setMemoria(byte posicao, byte servo, byte valor);
byte readMemoria(byte posicao, byte servo);
int ultMemoria;
void setup() {
servo1.attach(pinServo1);
pinMode(pinLedA, OUTPUT);
pinMode(pinLedB, OUTPUT);
pinMode(pinBotao1, INPUT_PULLUP);
pinMode(pinBotao2, INPUT_PULLUP);
ultMemoria = EEPROM.read(0);
}
202
void loop() {
static byte modo = 0;
static byte modoAnt;
static byte movimento = 0;
static byte posMemoria = 0;
static unsigned long delayPausa;
//Modo Normal
if (modo == 0) {
digitalWrite(pinLedA, LOW);
if (pinBotao2Retencao()) {
digitalWrite(pinLedB, HIGH);
//executa um movimento
if (movimento == 0) {
byte velocidade = map(analogRead(pinPot6),0,1023,0,255);
servo1.slowmove(readMemoria(posMemoria,0), velocidade);
//servo6.slowmove(readMemoria(posMemoria,2), velocidade);
servo6.slowmove(map(readMemoria(posMemoria,2), 0, 179, 179, 0),
velocidade); //Servo sincronizado inversamente ao Servo3
movimento = 1;
}
//aguarda término de um movimento para selecionar o próximo movimento

203
if ( (servo1.read() == readMemoria(posMemoria,0)) &&
(servo2.read() == readMemoria(posMemoria,1)) &&
(servo5.read() == readMemoria(posMemoria,4)) ) {
posMemoria++;
if (posMemoria > ultMemoria) { posMemoria = 0; }
delayPausa = millis();
movimento = 2;
}
}
//pausa entre movimentos

if ((millis() - delayPausa) > tempoPausaEntreMovimentos) {
movimento = 0;
}
}
} else {
digitalWrite(pinLedB, LOW);
if (pinBotao1Modo() == 2) {
modo = 1;
}
}
}
204
//Modo Gravação
if (modo == 1) {
if (modoAnt == 0) {
pinLedAPisca(true);
ultMemoria = -1;
EEPROM.write(0, ultMemoria);
}
pinLedAPisca();
if (pinBotao1Modo() == 2) {
modo = 0;
}
servo1.write( map(analogRead(pinPot1),0,1023,0,179) );
//servo6.write( map(analogRead(pinPot3),0,1023,0,179) );
servo6.write( map(analogRead(pinPot3),0,1023,179,0) ); //Servo sincronizado
inversamente ao Servo3
if (pinBotao2Apertado()) {
ultMemoria++;
EEPROM.write(0, ultMemoria);
setMemoria(ultMemoria, 0, map(analogRead(pinPot1),0,1023,0,179));
205
digitalWrite(pinLedB, HIGH);
delay(250);
if ( ultMemoria == (espacoMemoria - 1)) {

modo = 0;
}
}
}
modoAnt = modo;
}
byte pinBotao1Modo() {
#define tempoDebounce 40 //(tempo para eliminar o efeito Bounce EM
MILISEGUNDOS)
#define tempoBotao 1500
bool estadoBotao;
static bool estadoBotaoAnt;
static byte estadoRet = 0;
static unsigned long delayBotao = 0;
static byte enviado = 0;
if ( (millis() - delayBotao) > tempoDebounce ) {

estadoBotao = digitalRead(pinBotao1);
if (estadoRet == 0) {
if ( !estadoBotao && (estadoBotao != estadoBotaoAnt) ) {
206
estadoRet = 1;
delayBotao = millis();
}
}
if ( estadoBotao && (estadoBotao != estadoBotaoAnt) ) {
estadoRet = 0;
}
}
estadoBotaoAnt = estadoBotao;
}
if ((millis() - delayBotao) > tempoBotao) {
estadoRet = 2;
}
}
enviado++;
if (enviado >= 2) {
estadoRet = 0;
enviado = 0;
}
}
207
return estadoRet;
}
bool pinBotao2Retencao() {
MILISEGUNDOS)
bool estadoBotao;
static bool estadoRet = false;

estadoRet = !estadoRet;
}
}
}
return estadoRet;
}
bool pinBotao2Apertado() {
MILISEGUNDOS)
208
bool estadoBotao;
static bool estadoRet;
estadoRet = false;
estadoRet = true;
}
}
}
return estadoRet;
}
void pinLedAPisca(bool reset) {

static unsigned long delayPisca = 0;
if (reset) {
delayPisca = millis();
} else {
if ((millis() - delayPisca) < 500) {
209
digitalWrite(pinLedA, LOW);
} else {
digitalWrite(pinLedA, HIGH);
}
if ((millis() - delayPisca) >= 1000) {

delayPisca = millis();
}
}
}
void setMemoria(byte posicao, byte servo, byte valor) {

int posMem;
posMem = ((posicao * 5) + servo) + 1;

EEPROM.write(posMem, valor);
}
byte readMemoria(byte posicao, byte servo) {

int posMem;
posMem = ((posicao * 5) + servo) + 1;

return EEPROM.read(posMem);
}
RESULTADO
210
COMENTÁRIOS
211
Aula 01 – Senha com teclado
CRÉDITOS DA AULA
O QUE VAMOS FAZER?

.
SCRIPT ARDUINO
byte x = 0 ;
#include <Keypad.h>
#define Password_Lenght 5 // Give enough room for six chars + NULL char
char Data[Password_Lenght]; // 6 is the number of chars it can hold + the null char = 7
char Master[Password_Lenght] = "1A23";
byte data_count = 0, master_count = 0;
bool Pass_is_good;
char customKey;
const byte ROWS = 4; //four rows

const byte COLS = 4; //four columns
char hexaKeys[ROWS][COLS] =
{
{'1', '2', '3', 'A'},
212
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {7, 6, 5, 4}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {3, 2, 8, 9}; //connect to the column pinouts of the keypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins,
ROWS, COLS);
void setup()
{
Serial.begin(9600);
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
void loop()
{
if ( x == 0)
{
Serial.println("Enter Password");
x = 1;
}
customKey = customKeypad.getKey();
if (customKey) // makes sure a key is actually pressed, equal to (customKey !=
NO_KEY)
{
Serial.println(customKey);
Data[data_count] = customKey; // store char into data array
213
data_count++; // increment data array by 1 to store new char, also keep track of the
number of chars entered
}
if (data_count == Password_Lenght - 1) // if the array index is equal to the number of

expected chars, compare data to master
{
Serial.print("Password is ");
if (!strcmp(Data, Master)) // equal to (strcmp(Data, Master) == 0)

{ Serial.print("Good");
digitalWrite(13, 1);
}
else
{
Serial.print("Bad");
}
delay(1000);// added 1 second delay to make sure the password is completely

shown on screen before it gets cleared.
clearData();
}
}
void clearData()
{
while (data_count != 0)
{ // This can be used for any array size,
Data[data_count--] = 0; //clear array for new data
214
}
return;
}
RESULTADO
COMENTÁRIOS
215
Aula 01 – Fechadura com senha via teclado
CRÉDITOS DA AULA
https://www.instructables.com/id/Arduino-door-lock-with-password/
O QUE VAMOS FAZER?

Arduino Door Lock With Password: In this project I mede an door lock (or box lock) that opens when
you enter your password and press "#". The servo turns back to the position it was in after some
seconds.
216
SCRIPT ARDUINO
#include <Password.h> //http://playground.arduino.cc/uploads/Code/Password.zip

//tells to use password library
#include <Keypad.h> //http://www.arduino.cc/playground/uploads/Code/Keypad.zip
//tells to use keypad library
#include <Servo.h> //tells to use servo library
Servo myservo; //declares servo

Password password = Password( "0000" ); //password to unlock, can be changed
const byte ROWS = 4; // Four rows

const byte COLS = 4; // columns
// Define the Keymap
char keys[ROWS][COLS] = {
217
{'1','2','3'},
{'4','5','6'},
{'7','8','9'},
{'*','0','#'}
};
// Connect keypad ROW0, ROW1, ROW2 and ROW3 to these Arduino pins.
byte rowPins[ROWS] = { 9, 8, 7, 6 };// Connect keypad COL0, COL1 and COL2 to
these Arduino pins.
byte colPins[COLS] = { 5, 4, 3 };
// Create the Keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
void setup(){
Serial.begin(9600);
Serial.write(254);
Serial.write(0x01);
delay(200);
pinMode(11, OUTPUT); //green light
pinMode(12, OUTPUT); //red light
myservo.attach(13); //servo on digital pin 9 //servo
keypad.addEventListener(keypadEvent); //add an event listener for this keypad
}
void loop(){
keypad.getKey();
myservo.write(0);
}
//take care of some special events
void keypadEvent(KeypadEvent eKey){
switch (keypad.getState()){
218
case PRESSED:
Serial.print("Enter:");
Serial.println(eKey);
delay(10);
Serial.write(254);
switch (eKey){
case '*': checkPassword(); delay(1); break;
case '#': password.reset(); delay(1); break;
default: password.append(eKey); delay(1);

}
}
}
void checkPassword(){
if (password.evaluate()){ //if password is right open
Serial.println("Accepted");
Serial.write(254);delay(10);
//Add code to run if it works
myservo.write(150); //deg
digitalWrite(11, HIGH);//turn on
delay(5000); //wait 5 seconds
digitalWrite(11, LOW);// turn off
219
}else{
Serial.println("Denied"); //if passwords wrong keep locked
Serial.write(254);delay(10);
//add code to run if it did not work
myservo.write(0);
digitalWrite(12, HIGH); //turn on
delay(500); //wait 5 seconds
digitalWrite(12, LOW);//turn off
}
}
RESULTADO
220
COMENTÁRIOS
221
Aula 01 – Mão articulada
CRÉDITOS DA AULA
https://www.prometec.net/proyecto-mano-articulada/
O QUE VAMOS FAZER?

Construir uma mão artificial com controle de moviminetos mediante servos e de 6 graus de
liberdade.
Material electrónica:
Arduino
1
MEGA
Módulo
1 controlador
de servos
PCA9685
222
PWM o bien
servo shield
6 Joysticks
Fuente
1 alimentación
externa (1)
1 Protoboard
Cables
protoboard
Este proyecto de mano articulada no pretende ser una fiel reproducción de la mano humana,
pero sí una aproximación que reproduce con cierta similitud, las funcionalidades de esta.
La idea del proyecto surgió a raíz de este vídeo:
Donde es posible ver la enorme semejanza de la reproducción de las posibilidades de una mano
real.
El presente proyecto se compone de dos partes:
1. – La primera, Mecánica, de cómo se ha construido la mano con la mecánica, articulaciones y

movimiento.
2. – La segunda con la parte electrónica. .
223
1ª parte: La mecánica.
La construcción mecánica del conjunto lleva su tiempo, pero pienso que vale la pena.
Se ha confeccionado con los materiales y elementos que figuran a continuación, pero

evidentemente es susceptible de ser adaptados, tanto los unos como los otros, a la inventiva de
cada uno y a los elementos disponibles.
Materiales necesarios
Varilla de madera, mínimo de 12 mm Ø (es posible utilizar espigas de madera de las

1 utilizadas en la construcción de muebles, que ya vienen cortadas, y adaptarlas a
nuestras necesidades)
14 Articulaciones/bisagras cilíndricas 4x15mm

14
(http://www.aliexpress.com/snapshot/7149930408.html?orderId=71399652358380)
18 Cáncamos pequeños para madera
Pieza de madera plana, para la mano propiamente dicha, más larga para instalar los
1
servos, a la que se dará forma en su momento
224
Rollo de hilo de pescar trenzado Lure Braid 20/100
1
). Con unos pocos metros servirá.
6 Servos SG90 9g mini micro servo, con las bielas correspondiente (*)
1 Cinta elástica de mercería de 10mm
Tornillería variada
(*) Hemos utilizado estos servos porque era los que teníamos. Pero debe advertirse que al ser
económicos, de baja potencia y calidad, el resultado final no es el que podría esperase después
de tanto trabajo. Si se pretenden conseguir unos resultados más aceptables, será conveniente
reemplazarlos por otros de mejor calidad, más eficientes, pero también más caros.
Desarrollo
En primer lugar haremos una plantilla de la mano dibujada en un papel, para tener claras las
articulaciones y las medidas aproximadas de los dedos con las que trabajaremos:
225
Cortaremos la varilla a las medidas aproximadas de la longitud de cada falange.
Una vez
tengamos todas las piezas cortadas, habrá que hacer los agujeros centrales en cada una de ellas.
Para hacerlo con ciertas garantías, utilizaremos un soporte específico, que mantendrá los
cilindros perfectamente rectos y sujetos.
226
Si la varilla que
estamos utilizando es de 12 mm, en un bloque de madera haremos un agujero con una broca de
12 mm, lo más recto posible, en el que se insertará cada una de los cilindros, hasta que haga
tope al fondo (para ello será necesario haber calculado la profundidad del orificio, de manera
que permita que sobresalga una buena parte de la pieza.
• Nosotros hemos utilizado una máquina manual de perforar fija. Con una taladradora montada
en su soporte y la plantilla anterior, será fácil hacer los agujeros centrados en los extremos de
cada cilindro.
227
Posteriormente se colocaran las bisagras.
Previamente al montaje definitivo, habrá que tener en cuenta algunos detalles.
• Para que al montar los dedos a la mano, las gomas posteriores no obliguen a flexionarlos hacia
atrás, cosa que dificultaría o impediría la articulación natural de cada uno de ellos, antes de
encolar las bisagras, nos fijaremos en que queden bien empotradas, de manera que con los
dedos estirados las dos partes traseras tengan contacto (A).
228
• Habrá que limar las extremidades en el ángulo apropiado (B) (unos 45º), de manera que
permita la flexión de las dos partes a 90º (C).
• Recordad que la articulación inferior de cada dedo, que se unirá a la mano, también deberá
disponer del agujero correspondiente para insertar la bisagra. .
Vamos, ahora, a por la mano. De un pedazo de madera plana que tengamos (nosotros hemos
utilizado una franja de un palé, encolando y dando forma a dos piezas), haremos una pieza
aproximadamente como esta, procurando mantener una cierta proporción con la largada y
anchura de los dedos (hay que dejar espacio suficiente al final, para colocar los servos con
comodidad).
Acabaremos la parte superior, limando un poco para darle la forma aproximada de una mano
natural.
Se procederá a realizar los 4 agujeros, de los dedos meñique, anular, corazón e índice, en los
que se insertarán las bisagras, en la parte superior.
Una vez montado el sistema, quedará más o menos como las siguientes imágenes:
229
Para el dedo pulgar, el sistema de montaje es diferente, porque el movimiento natura es
diferente al resto de dedos. La parte inferior irá atornillada al rebaje de la mano, permitiendo el
libre movimiento. Habrá que pensar el ponerle algún tope para que el movimiento (hacia
arriba y hacia abajo) no sobrepase los límites de una articulación natural.
230
De la misma manera que hicimos individualmente con los dedos, para que no flexionen hacia
atrás, habrá que hacer algo para evitar dicha flexión con respecto a la mano y el conjunto
“digital”.
En este caso hemos colocado un tope (D) detrás del sistema “digital”. Con esta solución se
evita que los dedos flexionen para atrás de manera antinatural.
Se observan las articulaciones y topes (C) que permiten la movilidad funcional del conjunto
Procederemos a colocar los cáncamos que servirán de guía a los cables de cada unidad.
231
• Para evitar que los pequeños cilindros se abran e inutilicen al colocar los cáncamos, será
conveniente hacer unos agujeros preliminares de menor diámetro, antes de roscar los tornillos.
• Antes de encolar definitivamente los dedos al cuerpo de la mano y unirlo todo, será
conveniente mecanizar todo el conjunto, ya que dificulta mucho el trabajar con los dedos
montados.
Llegados a este punto, ya es posible sujetar las bandas elástica por la parte posterior de los
dedos. Recordar que es mejor hacerlo sin que estén estos pegados al cuerpo, dejando una buena
tira por debajo, para asegurarse que se pueda colocar bien en el cuerpo de la mano.
• La banda elástica es conveniente que sea ancha para que coja una buena superficie del
cilindro. Si es demasiado estrecha, al flexionar se desplazará hacia los lados y el movimiento de
la articulación fallará.
• La tensión de la banda elástica ha de ser suficiente para mantener los dedos hacia atrás, pero
que no exija una fuerza excesiva a las levas de los servos en la flexión. [/fancy-ul]
Una vez los cáncamos colocados y hechos los ajustes para ver que funcionen correctamente
todas las articulaciones, ya se puede proceder a pegar las bisagras al cuerpo de la mano, y a
sujetar las bandas elásticas a esta.
232
El conjunto
tendrá un aspecto similar a la imagen anterior en el reverso, y uno parecido a esto en el
anverso:
Se colocan los cables, de manera provisional, para comprobar el funcionamiento general de

todo el conjunto, y hacer los ajustes necesarios si fuera preciso.
233
Una vez se vea que está todo correcto, ya se puede pensar en la colocación de los servos. Pero
antes, hay que ampliar un poco la explicación. El lector atento se habrá dado cuenta que hay
algo que no cuadra; ¿6 servos, si hay 5 dedos?
La respuesta es que mientras los otros 4 dedos se gobiernan con un solos servo por dedo, el
pulgar está gobernado por dos servos: uno realiza el movimiento de flexión-extensión, igual
que los otros (en este caso concreto, izquierda-derecha), y el segundo, el movimiento sobre la
primera falange (adelante atrás). Más adelante se comprenderán con más claridad estos dos
movimientos.
• Durante la construcción de la mano, se hablaba de dejar espacio suficiente en la parte a atrás

para la colocación de los servos. Estos deberán tener una colocación especial y será necesario
algo de espacio para poder manipular los ajustes.
• A demás, si al final de todo, se pretende colocar un guante para darle más realismo al montaje
(cosa que no hemos hecho nosotros), el espacio entre la punta de la mano (no de los dedos), y
la colocación de los servos, deberá ser mayor, para evitar que los servos queden dentro del
guante y este estorbe las flexiones.
234
Como se puede observar en la imagen superior y en el diagrama inferior, cada servo tiene una
posición definida y diferente del resto.
235
Hay que tener en cuenta los movimientos de las levas, que no se estorben entre ellas ni tampoco
que se estrellen contra los servos, así como también el recorrido de los cables. En posiciones
similares a las de las imágenes, se sortean estos problemas.
Pero surge otro problema. Al tener montados los servos, las levas resultan demasiado cortas
para que las articulaciones de los dedos hagan la totalidad del recorrido correctamente.
Entonces será necesario pegarles unos alargos para aumentar el brazo de palanca y, por tanto, el
recorrido útil de los cables.
• Sirven pedacitos de palo de helado, pegados con cola termofusible, asegurándose que queden
bien unidos. Lo hemos hecho de esta manera, porque será posible recuperar las levas si al
terminar el proyecto necesitamos reutilizarlas. [/fancy-ul]
Una vez colocadas las levas en cada uno de los servos, sin atornillarlos aún, se procederá a
calibrarlos, de manera que cada leva haga el recorrido justo para realizar la flexión y extensión
completa de cada dedo, sin tensar en exceso los cables.
• Lo que hace referencia al movimiento de los servos con los joysticks, se verá en el capítulo de
programación, pero será necesario tener en cuenta algunos aspectos básicos a tener en cuenta
durante el montaje mecánico.
• En primer lugar, hay que recordar que el servo tiene un recorrido de barrido que va desde 0º a
180º. Hará falta tenerlo en cuenta para el montaje de las levas.
• Cada servo, incluso siendo de la misma marca, acostumbran a tener parámetros de calibrado
diferentes, por lo que será necesario calibrarlos independientemente. Esto se verá en la
programación, pero para seguir con el montaje, será necesario tenerlo en cuenta.
• Para empezar, hará falta colocar las levas de los servos en una determinada posición, sea de
reposo (0º) o en flexión (180º), para poder colocar los cables (si es en reposo, 0º, el cable
estará tensado justo para que quede el dedo ligeramente flexionado. Si está en flexión, el cable
deberá estar tensado, de manera que la punta del dedo toque la parte interna de la mano).
• Se tendrá en cuenta que, los servos S0, S1 y S2, se sitúan a la izquierda, mientras que los S3, S4
y S5 lo hacen a la derecha. Estas posiciones influirán, también, en la programación, tal y como
se verá en su momento, ya que las levas se moverán en sentidos contrarios con respecto al
cuerpo del servo.[/fancy-ul]
Es aconsejable realizar las pruebas de calibrado de los servos, con las levas montadas (sin
tornillo central de sujeción), y sin los cables sujetos, ya que estorbaran continuamente durante
el reglaje.
Una vez se tengan los servos calibrados, ya se puede proceder a sujetar los cables a las levas.
En este punto se trabajará mejor si se puede retirar la leva y hacer los nudos fuera, que si
hubiera de desenroscar los tornillos de sujeción.
236
La solución
que hemos encontrado para sujetar el otro extremo del cable a la punta del dedo, ha sido
colocarle un tornillo en lugar del primer cáncamo, de manera que enrollando el cable al tornillo
y apretando este, el cable queda sujeto con seguridad. Otra ventaja, es que será posible dar más
o menos largada al cable, para completar el reglaje de cada dedo.
La tensión de
los cables, en reposo (posición 0º), será la justa y necesaria para proporcionarle una pequeña
tensión a la falange distal del dedo, de manera que quede ligeramente levantada la punta. Esto
facilitará el inicio del movimiento de flexión, evitando que el servo deba hacer fuerzas
excesivas y/o que la estructura del dedo adopte posturas extrañas a causa de tensiones
inapropiadas.
237
Una vez
todos los servos calibrados, levas sujetas con tornillos y cables en su sitio, el proyecto quedará
un conjunto similar a la siguiente imagen:
2ª parte: La electrónica.
238
No se trata de un montaje complicado, pero tiene sus trucos y prioridades. La mayor dificultad
se encuentra en el calibrado de los servos. Ya se ha hecho mención de algunos aspectos en la
parte 1ª de La mecánica, pero a riesgo de repetirnos, volveremos a insistir en ellos más
adelante.
Pero vayamos por partes.
En este proyecto será necesario utilizar una placa Arduino MEGA, porque nos quedaríamos
cortos con una UNO, que tiene menos pins de entrada para conectar los joysticks.
El problema que presenta la Arduino MEGA, es que únicamente suministra un máximo

de 50mA, y los 6 servos consumen bastante más.
Para solucionar esta escasez, disponemos del módulo controlador de servos PCA9685, que
permite el gobierno de hasta 15 servos y que permite la alimentación externa exclusiva para los
servos.
En primera instancia hemos utilizado un cargador de móvil de 5V-2Ah (1), pero se queda un
poco corto. Lo sustituimos por una fuente de alimentación ATX de 5V-20Ah, y se percibe una
ligera mejoría, pero sigue dando alguna disfunción en los movimientos, que pensamos que es a
causa de poca calidad de los servos utilizados.
Por lo tanto, la fuente de alimentación externa habrá que adaptarla a la potencia de los servos
que se utilicen. Más vale sobredimensionar la intensidad, que quedarse cortos.
En primer lugar se fijan los joysticks en alguna base, de manera que, por una parte se tengan
controlados por orden y, por otra, permitan los movimientos sin tener que estar pendientes de
que se muevan anárquicamente.
239
Ahora pasemos al conexionado del módulo controlador de servos PCA9685.
Sin entrar en detalles del funcionamiento del módulo, las conexiones de los servos van a los
pines de colores, que van debidamente rotulados: de izquierda a derecha, se conecta el servo 0,
servo 1, servo 2… hasta el servo 5 en nuestro caso, pero podrían conectarse hasta 15 servos si
fuera necesario.
Y los colores corresponden, amarillo a PWM, rojo a Vcc y Negro a GND.

En la parte superior va la entrada de la alimentación externa de 5V, VCC y GND
240
A la izquierda el conexionado que unirá el módulo con la MEGA, según el siguiente esquema:
Modulo PCA9685 Arduino Mega
GND GND
OE GND
SCL 21
SDA 20
VCC 5V
V+ No connectado
El conexionado completo, en Firtzting, será como sigue:
241
• La placa PCA9685 (en rojo en la imagen), no se corresponde con la que se utiliza, pero el
conexionado sí que es correcto. [/fancy-ul]
Una vez realizado el cableado asegurándonos que es correcto, para evitar futuros fallos,
empezaremos con el programa.
Este programa hay que agradecerlo a Jesús Sánchez Medina, sin cuya colaboración y aliento, el
proyecto no hubiera sido posible.
Programa de control
En primer lugar habrá que descargar e instalar la librería de Adafruit, desde

Adafruit_PWMServoDriver.h, que gestionará el Modulo PCA9685. Y finalmente solo hará
falta cargar el siguiente sketch:
Mano_articulada_V2
242
Hay que insistir en que cada servo tiene sus propios parámetros de giro, por lo que será
necesario adaptar los valores de los ángulos a cada uno de ellos, en función de donde queramos
que esté en la posición 0º (extensión o reposo) y la posición 180º (extensión).
Os dejamos un vídeo del resultado final. Evidentemente cada uno puede adaptarlo a sus
necesidades y a su particular inventiva para mejorar cada paso.
Las posibilidades de programar diferentes grupos de movimiento de las articulaciones son

infinitas, desde hacer un programa que contenga determinados movimientos predefinidos,
eliminando los joysticks, hasta programarlos mediante pulsadores. Esto queda a gusto e
inventiva del usuario.
SCRIPT ARDUINO
RESULTADO
COMENTÁRIOS
243
Aula 01 – Uso de LED-s
CRÉDITOS DA AULA
O QUE VAMOS FAZER?

.
SCRIPT ARDUINO
RESULTADO
COMENTÁRIOS
244

Curso Básico de Arduino

Enviado por

Dados do documento

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, outubro de 2019

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

(Caso necessário, Download do drive USB2.0-Serial CH34x)

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

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

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

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

O QUE SÃO SHIELDS?

COMPONENTES DA PLACA ARDUINO

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

Download the Arduino Software (IDE)

Proceed with board specific instructions

Download the Arduino Software (IDE)

Choose the components to install

Proceed with board specific instructions

O QUE VAMOS FAZER?

Como acender um LED com o Arduino.

PEÇAS QUE SERÃO UTILIZADAS

PASSOS DA MONTAGEM DA PROTOBOARD

Passo 2 – Conecte o resistor na casa 5b e nos pinos negativos da protoboard.

O QUE VAMOS FAZER?

PEÇAS QUE SERÃO UTILIZADAS

• fio amarelo ao pino digital 2 do Arduino;

O QUE VAMOS FAZER?

Controlar um LED com um potenciômetro.

PEÇAS QUE SERÃO UTILIZADAS

Para fazer este projeto, serão necessários os seguintes componentes:

Conecte os fios jumper médios na protoboard, um na coluna 42 que é a perna do meio do

A conexão será feita da seguinte forma:

• fio azul (resistor e LED) no pino digital 8;

O QUE VAMOS FAZER?

PEÇAS QUE SERÃO UTILIZADAS

Para fazer este projeto, serão necessários os seguintes componentes:

Os fios jumpers grandes serão conectados da seguinte forma:

• fio azul no pino digital 11;

O QUE VAMOS FAZER?

00000001 (binário) é igual a 1 (decimal);

00000010 (binário) é igual a 2 (decimal);

00100001 (binário) é igual a 33 (decimal);

11111111 (binário) é igual a 255 (decimal).

Lembro que um LED aceso é igual a 1 e um led apagado é igual a 0.

PEÇAS QUE SERÃO UTILIZADAS

Para fazer este projeto, serão necessários os seguintes componentes:

• pino 1 do 74HC595 ligado ao positivo do 2º LED;

Depois de concluir o projeto físico, ou seja, a montagem e as conexões entre Arduino e

O QUE VAMOS FAZER?

Piscar um LED com efeito fader.

PEÇAS QUE SERÃO UTILIZADAS

Para fazer este projeto, serão necessários os seguintes componentes:

O QUE VAMOS FAZER?

PEÇAS QUE SERÃO UTILIZADAS

Para fazer este projeto, serão necessários os seguintes componentes:

O QUE VAMOS FAZER?

PEÇAS QUE SERÃO UTILIZADAS