Ardu Hack

Licensed to ALCEU DOMINGUES ALVES - aaalllceu@yahoo.com.
br - HP13215938283885
ARDUHACK
PARE DE COPIAR
PROJETOS E COMECE
A CONSTRUIR OS
SEUS AGORA MESMO
+ DE 15 PROJETOS BÔNUS
MÉTODO APROVADO
POR ALUNOS
DIRECIONADO A PRÁTICA
MATEUS D. DIAS
Licensed to ALCEU DOMINGUES ALVES - aaalllceu@yahoo.com.br - HP13215938283885
REVISÃO 1.5
SOBRE O AUTOR:
Mateus D. Dias é formado em Engenharia de Controle e

Automação, e trabalha com desenvolvimento IoT a mais de 2
anos. Possui experiencia em cloud computing, e é fundador da
empresa Vuker Tecnologias Inteligentes, na qual presta
consultoria para grandes empresas do setor de automação no
Brasil.
Trabalhando na área, viu o déficit de profissionais, por isso

tomou como missão criar a maior comunidade de
desenvolvimento IoT do Brasil.
Atualmente possui um projeto para ensinar

desenvolvedores a se especializarem em programação de
microcontroladores.
**********************************************************************************
CANAIS DE CONTATO:
Grupo no Telegram:
https://t.me/lobosdarobotica
Instagram:
https://www.instagram.com/lobodarobotica/
Blog Lobo da Robótica:
https://lobodarobotica.com/
Canal no Youtube:
https://lobodarobotica.com/canal-yt
Página do Facebook:
https://www.facebook.com/lobodarobotica/
Grupo do Facebook:
https://lobodarobotica.com/fb-grupo-arduhack
Grupo do Facebook:
https://lobodarobotica.com/wpp-arduhack
Acesso ao Minicurso BÔNUS:
https://lobodarobotica.com/acesso-minicurso
E-mail:
email@lobodarobotica.com
2
DEDICATÓRIA
Dedico esse livro primeiramente a Deus por me permitir

construir esse trabalho. Além do meu querido pai, e minha
querida mãe. Agradeço pelo esforço e dedicação.
3
POR QUE ESCREVI ESSE LIVRO
Diariamente recebo pedido de pessoas que querem

aprender a programar Arduíno e não sabem por onde começar,
ou ainda, sabem os conceitos básicos, mas não se sentem
confiantes para construir seus próprios projetos.
Veja bem, não há nada de errado em copiar projetos de

outras pessoas, ou até mesmo algumas partes de códigos, mas é
importantíssimo que você entenda o que você está copiando.
Uma criança aprende a falar, imitando as palavras dos pais,

até que se sinta confortável o suficiente para construir suas
próprias frases, e o processo de aprendizado na programação
não é diferente.
Por mais que você já saiba alguns conceitos que esse livro
vai te passar, eu recomendo fortemente que você não pule
capítulos, e execute todos os exercícios propostos, pois isso vai
te dar suporte para no futuro você construir projetos cada vez
maiores e mais complexos.
Cada capitulo deste livro foi projetado de maneira

sequencial, seguindo uma linha de raciocino, para que você
sempre consiga interligar as ferramentas.
Cada projeto foi pensado e construído para colocar em

pratica o que você aprendeu em cada capitulo, e nos capítulos
que o antecedem.
Bom Aprendizado!
4
SUMÁRIO
REVISÃO 1.5 ..................................................................................... 1
SOBRE O AUTOR: ........................................................................ 1
DEDICATÓRIA .................................................................................. 3
POR QUE ESCREVI ESSE LIVRO ...................................................... 4
CAPITULO 0 ...................................................................................... 9
0.1 APRESENTAÇÃO ...................................................................... 10
0.2 ARDUÍNO BLUEPRINT ............................................................ 12
CAPITULO 1 .................................................................................... 13
1.1 COMO FUNCIONA A PROTOBOARD? .................................... 13
1.2 CONVERSANDO COM O ARDUINO ....................................... 15
EXERCÍCIO 1.............................................................................. 21
1.3 VOID LOOP E VOID SETUP ..................................................... 22
1.4 ARMAZENANDO INFORMAÇÕES COM VARIÁVEIS............ 23
CONTEXTO DE VARIÁVEIS ..................................................... 26
#DEFINE E CONSTANTES ....................................................... 28
EXERCÍCIO 2.............................................................................. 31
1.5 OPERADORES ARITMÉTICOS – FAZENDO CÁCULOS
DURANTE A PROGRAMAÇÃO ...................................................... 32
ATRIBUIÇÃO (=) ....................................................................... 32
ADIÇÃO (+) ................................................................................ 33
SUBTRAÇÃO (-) ......................................................................... 35
MULTIPLICAÇÃO (*) ................................................................. 36
DIVISÃO (/) ................................................................................ 38
RESTO (%).................................................................................. 40
SOMA UNITÁRIA (++) .............................................................. 41
5
SUBTRAÇÃO UNITÁRIA (--) .................................................... 42

CAPITULO 2 .................................................................................... 43
2.1 OPERADORES LÓGICOS E DE COMPARAÇÃO ...................... 43
(==) IGUAL A: ............................................................................ 43
(>) MAIOR QUE ......................................................................... 44
(<) MENOR QUE ........................................................................ 44
(<=) MENOR IGUAL .................................................................. 44
(>=) MAIOR IGUAL: .................................................................. 45
(!=) DIFERENTE ......................................................................... 45
2.2 SE (EU ESTUDAR O ARDUHACK) {VOU FAZER PROJETOS
CADA VEZ MELHORES} ................................................................. 47
EXERCÍCIO 3:............................................................................. 51
EXERCÍCIO 4.............................................................................. 54
(!) NOT ........................................................................................ 55
(&) AND ...................................................................................... 55
(|) OR ........................................................................................... 56
2.3 SAÍDAS DIGITAIS: .................................................................... 57
PROJETO#1 - BLINK COM LED ..................................................... 60
EXERCÍCIO 5.............................................................................. 62
2.4 ENTRADAS DIGITAIS .............................................................. 63
PROJETO#2 – CONTROLANDO UM LED COM UM BOTÃO: ...... 64
EXERCÍCIO 6.............................................................................. 66
2.5 SWITCH-CASE .......................................................................... 67
EXERCÍCIO 7.............................................................................. 70
2.6 WHILE ....................................................................................... 71
EXERCÍCIO 8.............................................................................. 74
2.7 FOR ............................................................................................ 75
6
EXERCÍCIO 9.............................................................................. 77
EXERCÍCIO 10 ........................................................................... 78
PROJETO#3 – SCROLLING LED: ................................................... 79
2.8 DO-WHILE ................................................................................ 81
2.9 ENTRADAS ANALÓGICAS ...................................................... 82
CONVERSOR ANALÓGICO/DIGITAL ..................................... 82
PROJETO#4 – CONTROLANDO A FREQUÊNCIA DO LED COM
POTENCIÔMETRO: ........................................................................ 84
2.10 SAÍDAS ANALOGICAS........................................................... 86
PROJETO#5 – CONTROLANDO O BRILHO DO LED COM PWM:
.......................................................................................................... 90
CAPITULO 3 .................................................................................... 92
3.1 VETORES ................................................................................... 92
PROJETO#6 – CONTROLANDO LEDS EM SÉRIE COM
POTENCIÔMETRO: ........................................................................ 94
3.2 FUNÇÕES .................................................................................. 96
PROJETO#7 - ARDUINO CONTROLANDO SINALEIRO: ............ 98
PROJETO#8 – CONTROLANDO UM LED PELA LUMINOSIDADE
DO AMBIENTE: ............................................................................. 100
3.3 RETORNOS ............................................................................. 103
PROJETO#9 – LENDO UM SENSOR DE TEMPERATURA: ........ 106
3.4 PARÂMETROS ........................................................................ 109
3.5 CLASSES E BIBLIOTECAS ...................................................... 110
COMO INCLUIR BIBLIOTECAS .............................................. 111
PROJETO#10 – POSICIONAMENTO COM GPS NEO-6M .......... 119
PROJETO#11 – TOCANDO UMA MELODIA COM BUZZER: ..... 121
PROJETO#12 – CONTROLANDO UM SERVO: ........................... 125
7
PROJETO#13 – CONTROLANDO UM MOTOR DC: ................... 127

PROJETO#14 – DISPLAY LCD:..................................................... 130
PROJETO#15 - DHT11 SENSOR DE TEMPERATURA E UMIDADE
........................................................................................................ 132
PROJETO#16 - ARDUINO COM SENSOR DE MOVIMENTO PIR
........................................................................................................ 134
PROJETO#17 – ANALISE DE SOLO COM YL-69 OU HL-69: .... 136
IGNIÇÃO ........................................................................................ 138
8
KIT ARDUINO COMPLETO LOBO DA ROBÓTICA
Muitos dos projetos desse e-book, eu irei ensinar como

utilizar um simulador online para desenvolver. Mas é notável a
diferença de aprendizado dos alunos que montam fisicamente
os projetos.
Por esse motivo, montei um kit completo com o maior

numero de componentes, pelo menor preço disponível no
mercado.
Mateus, esse kit possui tudo o que preciso para construir

todos os projetos desse livro?
A resposta é não, pois o livro possui dezenas de projetos,

com os mais diversos componentes que existem.
O Kit Arduino completo Lobo da Robótica, possui os

componentes essenciais que você precisa ter.
Conheça mais através do link:
https://lobodarobotica.com/oferta-kit-alunos
9
CAPITULO 0
0.1 APRESENTAÇÃO
Agora que já nos conhecemos, está na hora de conhecer

como este livro está dividido.
Com certeza a melhor maneira de se aprender é

executando. Gosto de usar o seguinte exemplo:
“Imagine que você está em um caiaque, e você tem 2 remos

em suas mãos. O remo da mão esquerda é o remo do
aprendizado, já o da mão direita é o remo da execução. Se você
apenas remar sua mão esquerda, vai ficar girando em círculos e
não vai a lugar algum, e o mesmo vale para a mão direita.
Portanto de nada vale você aprender muito e não executar nada,
e não adianta você executar muito e nunca parar pra aprender.
Você só vai conseguir avançar se souber equilibrar as duas
coisas”.
Assim que você aprender algo novo nesse livro, vá e

coloque em prática!
Esse livro está dividido em explicações e exercícios, então a

cada novo capitulo que você estudar, terá exercícios para você
colocar em prática. Além de mais de 15 projetos bônus para você
construir, e colocar suas habilidades à prova.
Em cada capitulo eu irei explicar sobre um conceito novo

dentro do Arduíno e da programação C/C++, portanto pra cada
capitulo que você estudar você estará mais capaz de construir
10
suas próprias aplicações sozinho, de forma cada vez mais

profissional.
11
0.2 ARDUÍNO BLUEPRINT
Como bônus eu vou estar disponibilizando pra você o

ARDUÍNO BLUEPRINT, que é um mapa de tudo o que você pode
fazer com o Arduíno, contem explicações sobre as principais
funções e como você deve usar cada uma. É o caminho das
pedras que você precisa para construir suas aplicações. Quando
sentir dúvida em algo, basta consultar o Blueprint. O download
pode ser feito clicando no link abaixo:
https://lobodarobotica.com/arduino-blueprint
12
CAPITULO 1
1.1 COMO FUNCIONA A PROTOBOARD?
A primeira coisa que você precisa entender antes de sair

escrevendo linhas de código, são quais ferramentas você tem
disponíveis pra te ajudar nesse processo. E nesse caso a
ferramenta que eu acredito fortemente que é a mais importante,
tanto na parte de aprendizado, como na parte de
desenvolvimento é a PROTOBOARD.
Essa placa cheia de furos pode parecer estranha, mas

quando você entender a sua funcionalidade tudo vai ficar mais
claro.
Você precisa ter em mente que a protoboard é utilizada

para que não se tenha a necessidade de soldar componentes,
principalmente na etapa de desenvolvimento, sair soldando
componentes sem testar, não é uma coisa muito inteligente de
se fazer.
A figura 1 mostra como as furações da protoboard estão

interligadas. Na parte central, as furações são interligadas
verticalmente, mas são separadas horizontalmente. E é
justamente essa configuração que permite, com que liguemos
diversos tipos de Cis (Circuito Integrado), sem que seja fechado
um curto circuito no componente.
Já as laterais da protoboard, são usadas basicamente para

fornecer alimentação elétrica para os circuitos que iremos
montar, como você pode perceber, diferente da parte central, as
laterais são interligadas horizontalmente, e separadas
verticalmente.
13
Figura 1 – Protoboard.
A protoboard da imagem, é dividida em 6 regiões conforme

está marcada na figura 2:
Figura 2 – Região de ligações.
Cada região demarcada em vermelho está isolada das

demais, mas seguindo as regras de ligação que descritas acima.
Mais à frente, iremos construir circuitos usando a

protoboard, não se preocupe se esse conceito ainda está abstrato
pra você.
14
1.2 CONVERSANDO COM O ARDUINO
Se você me perguntar se é possível, “conversar com o

Arduino”, eu irei responder, “Sim! Não só é possível, como
fazemos isso o tempo todo”.
Nesse capitulo vamos estudar mais sobre a Serial, e como

essa função pode nos ajudar no desenvolvimento dos nossos
códigos.
A Serial é uma função nativa presente no Arduíno, que

permite fazer a comunicação entre o Arduíno e o computador,
ou outros dispositivos. De certa forma é um canal de
comunicação que temos disponível para enviar e receber dados.
Com a Serial é possível enviar informações do computador

para o Arduíno, e também fazer o caminho inverso.
A sintaxe de utilização é bem simples, basta inserir na

programação que queremos utilizar a Serial, com o comando
Serial.begin(); porem precisamos também indicar qual vai ser a
velocidade de comunicação, passando o parâmetro 9600, dentro
do Serial.begin(), ficando dessa maneira: Serial.begin(9600).
As coisas começaram a complicar? Parâmetro? Função?

Calma, estudaremos cada uma dessas áreas separadamente
quando for a hora. Por enquanto você precisa entender que para
usar a comunicação Serial, primeiro você precisa indicar ao
Arduino que você deseja isso, e também indicar qual vai ser a
velocidade da comunicação.
As velocidades de comunicação mais comuns de serem

utilizadas são, 9600 e 115200. Você também pode encontrar
referências a elas como baud rate.
15
Supondo que desejamos que, ao ligar o Arduíno, ele nos

envie a mensagem “Hello World”, como iremos fazer isso?
Já sabemos que o Serial.begin(9600) tem que estar

presente. Mas para o Arduíno enviar uma mensagem para o
computador, é necessário a função Serial.print(“Mensagem”).
A função Serial.print, é capaz de enviar um texto do

Arduíno para o computador, e o texto precisa ser passado entre
aspas dentro dos parênteses. Vamos ao nosso primeiro exemplo:
EXEMPLO:
void setup() {
//configura a comunicação serial com baud rate de 9600
Serial.begin(9600);
//Comando para que o Arduíno envie a mensagem Hello World
Serial.print("Hello World");
void loop() {
Apareceram duas funções aqui, void setup() e void loop(),

que estudaremos no próximo capitulo.
Repare também que existe a seguinte linha no código:
//configura a comunicação serial com baud rate de 9600
Essa é uma linha de comentário, ou seja, ela é ignorada pelo

Arduíno, e serve mais para você se localizar no código que você
estiver escrevendo. Se você se sentir confortável, pode escrever
quantas linhas de comentários quiser, dentro do seu código,
desde que cada linha tenha // no começo.
16
Você também pode indicar que deseja escrever várias

linhas de comentário usando /* Comentário aqui */, como
mostra o exemplo abaixo:
Exemplo:
void setup() {
/* Eu sou um comentário de várias linhas, e sirvo para

quando você precisa digitar um texto grande dentro do seu
código */
//configura a comunicação seria com baud rate de 9600

Serial.begin(9600);
//Comando para que o Arduíno envie a mensagem Hello World
Serial.print("Hello World");
void loop() {
Você pode testar esse código no seu Arduíno, ou pode

também testar online usando a plataforma TinkerCAD. Eu
tenho um ebook exclusivo ensinando como usar essa
ferramenta, que você pode baixar gratuitamente clicando AQUI.
Mas, muita atenção, até o momento em que publico esse

ebook, não é possível utilizar bibliotecas dentro da plataforma, e
apesar de ser uma ferramenta incrível, a falta desse recurso fará
falta no seu aprendizado. Minha recomendação é que os
exemplos e exercícios, você faça online, mas os projetos montem
fisicamente.
Ao executar o código do exemplo, a saída que você deve

obter deve ser a seguinte:
17
Figura 3 – Serial Monitor.
Porém o Serial.print() tem uma peculiaridade, ele sempre

exibe as informações na mesma linha, ou seja, se você colocar
mais um Serial.print(“Hello World”), seguido do que já existe, o
resultado deve ser algo parecido com “Hello WorldHello World”.
Para resolver esse problema, existe a função

Serial.println(), que executa o mesmo que a função Serial.print,
com a diferença de que depois de cada função, ele insere uma
quebra de linha, em outras palavras, ele “pula” uma linha.
Vejamos o exemplo abaixo:
Exemplo:
void setup()
{
Serial.begin(9600);
Serial.println("Hello World");
}
void loop()
{
}
Quando esse código é executado, você deve receber um

resultado igual ao da imagem abaixo:
18
Figura 4 – “Hello World” através da Serial.
Problema resolvido. Já sabemos como fazer o Arduíno

enviar uma informação para o computador, e como fazer essa
informação pular uma linha após ser escrita.
Pronto Mateus, podemos ir pro próximo capitulo?
A resposta é: Ainda não. Tem mais uma coisa muito

importante que precisamos discutir aqui, sobre a Serial. Já
sabemos como enviar uma informação do Arduíno para o
computador, mas e enviar uma informação do computador para
o Arduíno?
Para fazer isso, temos que usar a função Serial.read().

Vamos ao exemplo:
EXEMPLO:
void setup() {
//configura a comunicação seria com baud rate de 9600
Serial.begin(9600);
}
void loop() {
if (Serial.available()) //verifica se tem dados diponível

para leitura
{
19
Serial.write(Serial.read()); //reenvia para o

computador o dado recebido
}
}
Se você executar esse código, vai perceber que ele não exibe
nada na tela, porém se enviarmos um caractere através da Serial,
você irá perceber que o mesmo caractere aparece sendo
imprimido na tela. Então o que está acontecendo nesse código?
Nele, existem funções que estudaremos mais a frente,

como por exemplo o if(), mas o intuito no momento é entender
exatamente como utilizar a Serial. Quando você digita algo no
seu teclado e envia; os dados são recebidos pela função
Serial.read(), que está dentro da função Serial.write, cujo o
objetivo, nada mais é que devolver pro computador, o que ele
acabou de enviar.
Difícil? O importante é que você tente executar os

exemplos por conta própria, e verifique se os resultados que você
está obtendo, são os que eu estou descrevendo aqui. Vamos
continuar?
20
EXERCÍCIO 1
Desenvolver um código que exiba o seguinte texto:
OBS: O texto precisa ser exibido exatamente como está abaixo, e

com as mesmas quebras de linha. Para isso use os comandos
Serial.print() e Serial.println().
Internet das Coisas.
O Arduino tem um
trabalho
muito importante
no
desenvolvimento e
prototipagem
de
produtos IoT.
Desenvolvimento
rapido e eficiente, o
Arduino eh uma
ferramenta muito
poderosa.
Clique AQUI para ver a resolução do exercício.
21
1.3 VOID LOOP E VOID SETUP
Vamos aprender agora as duas principais funções nativas

que estão presentes na programação do Arduíno, e que você
também vai encontrar em qualquer outro dispositivo que utilize
o framework do Arduíno.
Imagine um avião prestes a levantar voo, para não ter

perigo de ocorrer algum problema no ar, o piloto se encarrega de
fazer várias verificações antes de partir. “Combustível, OK”,
“Pressão, OK”, “Preparando para decolar voo”. É exatamente essa
a função do void setup(), ele é responsável por preparar o
Arduíno para a execução do programa, fazendo verificações e
instanciando dados.
Tudo o que precisamos que o Arduíno execute uma vez

antes de iniciar o seu ciclo, deve ficar dentro do void setup. Por
isso quando instanciamos a Serial, o código estava presente
dentro do setup e não do loop.
Tá, se o setup é a preparação, pra que serve o loop então?
O void loop é a função que irá ser repetida enquanto o

Arduíno permanecer ligado. Se por um acaso tivéssemos
colocado Serial.println(“Hello World”) dentro do void loop(),
veríamos a mensagem “Hello World” ser mostrada infinitas
vezes na tela, enquanto o código permanecesse em execução.
Resumindo, o programa que você vai efetivamente

escrever, deve ficar dentro do void loop() pois este se repete
infinitamente enquanto o dispositivo permanecer ligado.
22
1.4 ARMAZENANDO INFORMAÇÕES COM

VARIÁVEIS
Chegamos ao momento mais importante do nosso

capitulo, o que iremos aprender aqui vai ser usado em cerca de
99% de todos os códigos daqui pra frente.
O Arduíno possui integrado, várias memórias que são

capazes de armazenar informação. Uma variável nada mais é do
que uma ordem para o Arduíno usar um pedacinho das
memórias que ele tem disponível, pra armazenar alguma
informação que desejamos.
Mas o melhor de tudo é que, as variáveis permitem

alteração nos valores que estão dentro delas, durante a execução
do código. Nas linguagens C/C++ existem diversos tipos de
variáveis disponíveis para a utilização, veja algumas delas:
• int – Armazena um número inteiro. Ex: 256

• float – Armazena um número com casas decimais. Ex:
5.25
• long – Armazena um número muito grande. Ex:
196819819
• char – Armazena um caractere. Ex: ‘c’
• String – Armazena um texto. Ex: “Hello World”
• bool – Armazena um booleano. Ex: true
Podemos atribuir um valor pra uma variável dentro do

programa, usando o sinal de igualdade (=).
23
SINTAXE:
Tipo Nome = valor
EXEMPLO:
/*
boolean: valor verdadeiro (true) ou falso (false)
char: um caractere
byte: um byte, ou sequência de 8 bits
int: número inteiro de 16 bits com sinal (-32768 a 32767)
unsigned int: número inteiro de 16 bits sem sinal (0 a
65535)
long: número inteiro de 16 bits com sinal (-2147483648 a
2147483647)
unsigned long: número inteiro de 16 bits sem sinal (0 a
4294967295)
float: número real de precisão simples (ponto flutuante)
double: número real de precisão dupla (ponto flutuante)
String: sequência de caracteres
void: tipo vazio (não tem tipo)
*/
int numero = 15;

float numero_virgula = 15.5;
long numero_grande = 15684651841;
char caractere = 'c';
String texto = "Hello World";
bool teste = false;
void setup()
{
void loop()
{
}
Conforme eu disse acima, o valor de uma variável pode

mudar ao longo da execução de um programa, basta atribuir o
novo valor com o sinal de igual, como mostra o exemplo abaixo:
24
EXEMPLO:
//O número 15 está armazenado dentro da variável numero
int num = 15;
void setup()
{
/*A partir desse momento a variável número passa a ter
o valor 625*/
num = 625;
}
void loop()
{
}
Também é possível usar a Serial para nos mostrar qual o

valor que está armazenado dentro de uma variável. Veja o
exemplo:
EXEMPLO:
int num = 15;
float num_virgula = 15.5;
long num_grande = 15684651841;
char caractere = 'c';
String texto = "Hello World";
bool teste = false;
void setup()
{
Serial.begin(9600);
Serial.print("Numero inteiro: ");

Serial.println(num);
Serial.print("Numero com casas decimais: ");

Serial.println(num_virgula);
Serial.print("Numero muito grande: ");

Serial.println(num_grande);
Serial.print("Caractere: ");
Serial.println(caractere);
25
Serial.print("Texto: ");
Serial.println(texto);
Serial.print("booleano: ");
Serial.println(teste);
void loop()
{
}
O resultado desse código é mostrado na Figura 5:
Figura 5 – Variáveis sendo imprimidas na Serial.
OBS: Se você tentar exibir um texto com acento, ou com “ç”,

pode ser que o Arduíno não entenda e exiba alguns caracteres
sem sentido no lugar.
OBS: O valor booleano false, é equivalente a 0, assim como

o valor true é equivalente a 1.
CONTEXTO DE VARIÁVEIS
Legal, sabendo os tipos de variáveis, precisamos entender

sobre os contextos de variáveis. Dependendo da onde a variável
é declarada, pode interferir como ela será acessada durante o
programa.
26
Basicamente podemos categorizar as variáveis em 2 tipos,

sendo elas as variáveis locais e as variáveis globais.
De maneira simples, podemos entender que as variáveis,

globais podem ser acessadas de qualquer lugar do código,
independente se estão dentro das funções nativas do Arduíno,
ou em funções criadas. Dessa maneira você pode entender, quer
quando uma variável global é criada, o valor que está
armazenado dentro dela pode ser acessado de qualquer lugar.
“Variáveis globais podem ser acessadas de qualquer lugar do

programa”
EXEMPLO:
String text = "Hello World";
void setup() {
Serial.begin(9600); // inicia a Serial
Serial.println(text); // referenciando a variável global
text
}
void loop() {
text
delay(5000);
}
Como complemento, as variáveis locais podem ser

acessadas apenas dentro do “contexto” em que elas foram
criadas. Dessa maneira você pode criar várias variáveis locais
com o mesmo nome, desde que estejam em contextos diferentes,
isso porque elas não têm relação uma com a outra.
“Variáveis locais existem apenas dentro do contexto em que

foram criadas”
27
EXEMPLO:
void setup() {
String text = "Eu so existo dentro do setup";

text
}
void loop() {
String text = "Eu so existo dentro do loop";
text
delay(5000);
}
#DEFINE E CONSTANTES
Em alguns momentos, pode ser que precisemos usar

algumas variáveis para armazenar dados estáticos. Isso pode
parecer ambíguo, “armazenar um dado estático em uma
variável”, mas deixe-me te explicar o motivo pelo qual isso é
importante.
Nesse momento você já deve entender um pouco mais

sobre a estrutura do Arduíno, e do programa.
Sabendo disso, como vimos um pouco antes, podemos

definir variáveis para armazenar valores, e que esses valores
inclusive podem ser alterados conforme o fluxo do programa.
Más além disso, podemos guardar outros tipos de informações
dentro das variáveis, como por exemplo dados de pinagens.
Como assim guardar pinagens? Digamos que você queira

acender uma lâmpada usando o Arduino, em algum momento
você vai precisar dizer na programação que você deseja usar uma
28
porta, e que ela deva trabalhar como uma saída (calma, mais a
frente vamos estudar isso a fundo). Nesse “dizer ao Arduíno que
desejamos usar uma porta” nada mais é do que uma referência
numérica, ao pino em que será feito o acionamento.
O Arduíno tem diversas portas que podem ser

manipuladas, e cada porta possui uma identificação, ou
numeração.
Ao fazermos um acionamento, podemos referenciar essa

identificação, todas as vezes que a utilizarmos. Ou melhor ainda,
podemos criar uma variável que armazena essa referência.
Para que um código seja enviado para dentro do

microcontrolador, primeiro ele precisa ser verificado por uma
espécie de “robô”, chamado de compilador. O compilador faz a
verificação do código, para saber se está tudo em ordem, e que
esse algoritmo pode ser enviado para dentro do dispositivo sem
causar problemas. (Possivelmente você vai conhecer o
compilador logo, pois é ele quem dá os avisos de erro no código).
Agora entramos na questão chave, o Arduínos possui

memorias, e isso já sabemos, porem essas memórias são
limitadas, e devemos usar de maneira inteligente.
Se você optar por usar a numeração do pino em todos os

lugares, você vai estar ocupando espaços de memória de
maneira desnecessária. E é aí que entram as variáveis.
Usando as variáveis para armazenas esses dados, o

compilador entende que não precisa repetir a mesma
informação várias e várias vezes durante o código, então ele
armazena essa informação apenas uma vez, e a partir disso usa
apenas referências a esse espaço de memória.
Usando o #define é uma mensagem clara ao compilador, de

que esse valor que está armazenado, não precisa ser repetido.
29
SINTAXE:
#define pin 10 //cria uma referência ao pino 10 chamada

pin
O mesmo vale para a utilização do const, o compilador

entende que essa é uma variável de referência, e que esse valor
não vai mudar ao longo do código.
SINTAXE:
const int pin = 8 //cria uma variável constante que

armazena o número do pino 8,
Portanto, quando são usadas as referências #define, ou

const, você está dizendo claramente ao compilador: “Estou
armazenando algo que não vai mudar ao longo do código”.
Vale deixar uma coisa bem clara, você não pode fazer
alterações nessas variáveis ao longo do programa, isso por que
quando seu código foi enviado ao microcontrolador, ele entende
que esse tipo de variável só pode ser lida em outras partes do
programa, e não pode ser modificada.
30
EXERCÍCIO 2
Construa um algoritmo que receba incialmente os

seguintes valores para as variáveis:
• dolar = 5.23;
• nome = “Harv”;
• alarme = false;
Faça com que essas variáveis sejam printadas na serial com a

seguintes Strings:
• “Cotação do Dolar e: “
• “Meu nome e: “
• “O status do alarme e: “
Após exibir essas 3 variáveis em tela, substitua ainda

dentro do mesmo código, a variável dolar para a cotação atual do
dolar no dia que você estiver executando, a variável nome para
seu nome, e a variável alarme para true.
Clique AQUI para ter acesso ao exercício resolvido.

31
1.5 OPERADORES ARITMÉTICOS –

FAZENDO CÁCULOS DURANTE A
PROGRAMAÇÃO
Se estamos construindo uma aplicação, é por que ela tem

uma finalidade, e na maioria das vezes precisamos executar
alguns cálculos matemáticos dentro da aplicação, e para isso
existem os operadores aritméticos. Nesse capitulo vamos
desmembrar um por um dos operadores disponíveis na
programação. Vamos lá:
ATRIBUIÇÃO (=)
Já vimos nos exemplos acima, que nas linguagens de

programação, o operador de atribuição é o sinal de igualdade (=),
e sua principal função é atribuir um valor para uma variável.
EXEMPLO:
int i = 25;
int j = 0;
void setup() {}
void loop()
{
32
ADIÇÃO (+)
O operador de adição, ou soma, é o mesmo usado na

matemática, o sinal de “mais” (+), e sua função é atribuir uma
soma de dois valores.
SINTAXE:
soma = operando1 + operando2;
EXEMPLO:
int i = 3;
int j = 2;
int k = 0;
void setup()
{
k = j + i;
Serial.begin(9600);
Serial.print("Valor de i: ");
Serial.println(i);
Serial.print("Valor de j: ");
Serial.println(j);
Serial.print("Valor de k: ");
Serial.println(k);
}
void loop()
{
Também existe uma abreviação de soma que pode ser

utilizada, que é (+=), esse tipo de abreviação significa que a
variável vai receber o valor dela mesma mais alguma coisa.
33
Por exemplo, se uma variável x vale 50, e você deseja somar

12 a esse valor, você não pode fazer a atribuição direta como:
x = 12
Pois dessa maneira o Arduino vai entender que é para

remover o 50 e substituir por 12. Um meio de fazer isso é usando
a sintaxe:
SINTAXE:
x = x + 12; // dessa maneira o x irá receber o valor de x que

é 50 mais o 12.
Ou você pode usar a abreviação desse modo que é (+=)
SINTAXE:
x += 12; // surte o mesmo efeito do exemplo acima.
EXEMPLO:
int s = 600;
void setup() {
s = s + 10; // soma 10 unidades a s
Serial.println(s); //imprime o valor de s
s = 600; // atribui novamente 600 unidades a s
s += 10; //maneira abreviada de somar 10 unidades a s

Serial.println(s);
}
void loop() {
34
SUBTRAÇÃO (-)
Também sendo o mesmo símbolo usado na matemática , o

operador de subtração (-) tem sua função de subtrair um valor
do outro.
SINTAXE:
diferenca = operando1 – operando2;
EXEMPLO:
int i = 3;
int j = 2;
int k = 0;
void setup()
{
k = j - i;
Serial.begin(9600);
Serial.println(i);
Serial.println(j);
Serial.println(k);
}
void loop()
{
Da mesma maneira que a soma, caso você precise subtrair

um valor da variável, sem apagar o valor antigo você pode usar
a sintaxe:
35
SINTAXE:
x = x – 12; // irá subtrair o valor 12 da variável x, sem

apagar o valor anterior
E também possui a abreviação:
SINTAXE:
x -= 12; // surte o mesmo efeito do exemplo anterior
EXEMPLO:
int s = 600;
void setup() {
s = s - 10; // subtrai 10 unidades a s
s = 600; // atribui novamente 600 unidades em s
s -= 10; //maneira abreviada de subtrair 10 unidades a s

Serial.println(s);
}
void loop() {
MULTIPLICAÇÃO (*)
Na programação C/C++ o operador de multiplicação

utilizado é o símbolo de asterisco (*), e sua função é multiplicar
um valor sobre o outro:
36
SINTAXE:
multiplicacao = operando1 * operando2;
EXEMPLO:
int i = 3;
int j = 2;
int k = 0;
void setup()
{
k = j * i;
Serial.begin(9600);
Serial.println(i);
Serial.println(j);
Serial.println(k);
}
void loop()
{
De mesmo modo, a multiplicação também possui a

propriedade de construir uma multiplicação composta.
SINTAXE:
x = x *50 // irá multiplicar o valor de x por 50 e atribuir

novamente a x
No modo abreviado fica:
37
SINTAXE:
x *= 50 // surte o mesmo efeito do exemplo anterior
EXEMPLO:
int s = 250;
void setup() {
s = s * 10; // multiplica 10 unidades em s
s = 250; // atribui novamente 250 unidades em s
s *= 10; //maneira abreviada de multiplicar 10 unidades

em s
Serial.println(s);
}
void loop() {
DIVISÃO (/)
O símbolo do operador de divisão usado na linguagem é a

barra (/), e sua função é dividir um valor pelo outro.
SINTAXE:
div = operando1 / operando2;
EXEMPLO:
int i = 2;
int j = 4;
int k = 0;
38
void setup()
{
k = j / i;
Serial.begin(9600);
Serial.println(i);
Serial.println(j);
Serial.println(k);
}
void loop()
{
Assim como os 3 casos anteriores, é possível fazer a divisão

de uma variável por ela mesma sem apagar o dado anterior
armazenado.
SINTAXE:
x = x/10; // divide o valor de x por 10 e atribui novamente

a x o novo valor
De modo abreviado
SINTAXE:
x /= 10; //surte o mesmo efeito do exemplo anterior
EXEMPLO:
int s = 250;
void setup() {
39

s = s / 10; // divide 10 unidades em s
s = 250; //atribui novamente 250 a variável s
s /= 10; //maneira abreviada de dividir 10 unidades em s

Serial.println(s);
}
void loop() {
RESTO (%)
E por último existe o operador de resto, representado pelo

sinal de porcentagem (%), esse operador permite saber se existe
resto em uma divisão de um inteiro pelo outro. Esse operador
também pode ser chamado de módulo, apesar do nome, não
confunda com o módulo da matemática (|x|), que na linguagem
do Arduíno é calculado por abs().
SINTAXE:
resto = dividendo % divisor;
int x = 0;
x = 7 % 5; // x agora contém 2
40
SOMA UNITÁRIA (++)
A soma unitária é muito usada dentro laços de repetição

conforme vamos ver nos capítulos seguintes, mas sua função é
acrescentar 1 unidade a mais na variável.
SINTAXE:
i++;// adiciona 1 unidade a variável i
é equivalente a:
i = i + 1;
ou
i += 1;
EXEMPLO:
int i = 0;
void setup() {
}
void loop() {
Serial.println(i);
i++; // adiciona 1 unidade a i cada vez que o loop é
executado
delay(5000);
}
41
SUBTRAÇÃO UNITÁRIA (--)
A subtração unitária tem o mesmo propósito da soma, e

pode ser usada para fazer a subtração de 1 unidade em uma
variável:
SINTAXE:
i--; //subtrai uma unidade no valor de i
é o equivalente a:
i = i - 1;
ou
i -= 1;
EXEMPLO:
int i = 500;
void setup() {
}
void loop() {
Serial.println(i);
i--; // subtrai 1 unidade a i cada vez que o loop é
delay(5000);
}
42
CAPITULO 2
2.1 OPERADORES LÓGICOS E DE

COMPARAÇÃO
As linguagens C/C++ permitem utilizar operadores lógicos

e de comparação dentro dos algoritmos, nesse capitulo vamos
estudar mais a fundo cada um deles e qual a sua utilização.
Já vimos acima que dentro da lógica de programação, o

sinal de igualdade (=) não é utilizado para equivaler dois valores,
e sim com o intuito de atribuição, mas então qual é o a
simbologia usada para a igualdade?
Dentro dos algoritmos o sentido de igualdade é dado pela

utilização de dois sinais de iguais (==), conforme vamos estudar
abaixo:
(==) IGUAL A:
Faz a comparação da variável da esquerda com a variável a

direita do operador, e também retorna o valor verdadeiro (true)
quando as duas são iguais.
SINTAXE:
x == y //retorna true se os valores forem iguais, e false se

forem diferentes.
43
(>) MAIOR QUE
Compara se o valor da variável esquerda do operador é

maior que o valor da variável direita do operador, quando o valor
da esquerda for maior que o valor da direita, ele retorna
verdadeiro (true).
SINTAXE:
x > y //retorna true se x for maior que y, e false se x for

menor ou igual a y.
(<) MENOR QUE
Esse operador faz o inverso do que o operador de MAIOR

QUE, ele compara se o valor da variável que está à esquerda do
operador é menor do que o valor da variável direita do operador.
SINTAXE:
x < y// retorna verdadeiro se x for menor que y e false se x

for maior ou igual a y
(<=) MENOR IGUAL
O operador menor que retorna um valor true, quando a

variável da esquerda menor do que a variável da direita, porém
ele retorna false se as duas forem iguais, o operador MENOR
IGUAL veio para resolver esse problema, caso na sua lógica você
44
precise comparar se a variável x é menor, ou igual a variável y,

esse operador vai retornar o valor true:
SINTAXE:
x <= y //retorna true caso x seja menor ou igual ao valor de

y
(>=) MAIOR IGUAL:
Assim como o operador MENOR IGUAL, o operador MAIOR

IGUAL é inclusivo no valor a ser comparado, portanto ele
retorna true também, se o valor da variável que está à esquerda
do operador for maior, ou igual, o valor que está na variável a
direita.
SINTAXE:
x >= y //retorna true caso o valor de x seja maior, ou igual

ao valor armazenado dentro de y.
(!=) DIFERENTE
Assim como existe o comparador de igualdade (==), existe

também o comparador de diferente.
Esse operador é utilizado para quando você quiser

comparar dois valores ou variáveis, e dizer se eles são diferentes.
45
SINTAXE:
x != y //retorna true caso o valor de x seja diferente que o

valor de y
Meio complexo? Não se preocupe, estamos perto de ter

todas as ferramentas necessárias, para você começar a construir
seus próprios códigos, no próximo capítulo vamos estudar a
lógica If Else, e você irá entender melhor como são utilizados os
operadores.
46
2.2 SE (EU ESTUDAR O ARDUHACK) {VOU

FAZER PROJETOS CADA VEZ MELHORES}
Achou estranho o título desse capítulo? Se você entendeu a

ideia do título, você já aprendeu também o laço condicional if().
Se você não entendeu ainda, vamos a explicação:
Diariamente em nossas vidas usamos esse laço

condicional, deixa eu te dar alguns exemplos: Se estiver dia,
apague as luzes, ou, se começar a chover, feche as janelas; ainda
se o celular estiver sem bateria, coloque-o carregar. Na
programação, conseguimos fazer exatamente a mesma coisa
usando o laço condicional if(). Isso serve para quando desejamos
fazer alguma verificação, antes de executar um algoritmo.
Se o botão for pressionado, acenda o LED.
Se estiver escuro, ligue a lâmpada.
Se x for menor que 50, aumente a velocidade da máquina.
E sim, essa é a última etapa para começarmos a colocar

nossas ideias em prática. Então vamos aos estudos.
Todas as lógicas que estudamos acima, os operadores

lógicos e de comparação podem ser usados dentro do laço if().
SINTAXE:
if(verificação) {
//Aqui dentro fica o que deve ser feito caso a verificação

seja verdadeira
47
EXEMPLO:
/* Deixamos armazenado qual é o pino do LED, dentro da
variável pinoLED */
int pinoLED = 13;
int x = 130;
void setup()
{
// Definimos o pinoLED como um pino de saída
pinMode(pinoLED, OUTPUT);
/* Se x for maior que 120 então a lógica MAIOR QUE, irá

retornar verdadeiro e executar o que está dentro do IF */
if (x > 120) {
// Se x for maior que 120 o pinoLED é acionado.
digitalWrite(pinoLED, HIGH);
}
void loop()
{
}
Perceba que no exemplo acima, dentro da verificação do if()

eu usei o operador de comparação (MAIOR QUE), lembre-se que
esse operador retorna verdadeiro (true) quando...?
Isso mesmo, quando a variável da esquerda do operador for

maior que a variável da direita. Portanto, no exemplo acima
como x possui o valor de 130 armazenado. 130 é maior que 120,
então o código que está dentro do if() vai ser executado.
Se x (possui o valor 130 armazenado) for maior que 120,

então o Arduíno irá acionar o pinoLED, com o comando
digitalWrite(). Esse comando estudaremos no próximo capitulo,
onde iremos fazer nossos primeiros acionamentos com o
Arduino. Mas o importante agora é você entender como o if()
funciona, para que possamos usar nas nossas próximas lógicas.
Então vamos ver mais alguns exemplos:
48
EXEMPLO:
int x = 45;
int y = 92;
void setup()
{
Serial.begin(9600);
if (x <= y) {// testa se x é menor que ou igual a y
/* Se x for menor ou igual a y a seguinte mensagem será

exibida na Serial: */
Serial.println("x eh menor ou igual a y");

}
}
void loop()
{
}
O laço if() também pode ser usado em sequência, imagine

que você esteja lendo um nível de uma caixa d’agua, e você deseja
saber quando o nível dela está: abaixo de 50% ou acima de 50%.
Você poderia usar a seguinte lógica:
EXEMPLO:
int caixadagua = 48;
void setup()
{
Serial.begin(9600);
if (caixadagua <= 50) {// testa se a caixa está com menos

de 50% ou igual a 50%
// Se a variável caixadagua estiver com menos de 50
exibe na tela a mensagem "A caixa está abaixo de 50%"
Serial.println("A caixa está abaixo de 50%");
}
if (caixadagua > 50) {// testa se a caixa está com mais
de 50%
// Se for maior exibe na tela a mensagem "A caixa está
com mais de 50%"
Serial.println("A caixa está com mais de 50%");
}
49
void loop()
{
}
50
EXERCÍCIO 3:
Desenvolver um algoritmo que verifique uma variável com

o laço if(). O código deve possuir os seguintes requisitos:
• Deve conter uma variável chamada luminosidade do

tipo int
• Deve conter uma variável chamada status do tipo
bool
• Deve verificar com o laço if se a variável
luminosidade é maior que 500, caso seja, deve fazer a
variável status receber false, e exibir a seguinte
mensagem na Serial: “A luz estah desligada”
• Deve verificar se a variável luminosidade é menor ou
igual a 200, caso seja verdadeiro, deve fazer a variável
status receber true, e exibir a seguinte mensagem na
Serial: “A luz estah ligada”.
• OBS: Lembre-se de não utilizar acentos ou caracteres
especiais nas mensagens da serial, pois ela pode não
entender,
51
O laço if é uma ferramenta fundamental para o

desenvolvimento de códigos eficazes, e além disso ela traz
consigo um complemento, que é a função else. E pra que ela
serve?
A função else nada mais é do que o “SENÃO” da vida real.

Vamos voltar aos exemplos:
• Se estiver escuro, ligue a lâmpada, senão deixe-a

desligada
• Se começar a chover feche as janelas, senão as deixe
abertas
• Se o botão for pressionado acenda o LED, senão deixe
ele desligado
O else é muito útil quando desejamos testar algo, e caso esse

teste não seja verdadeiro, o algoritmo execute alguma outra
coisa, vejamos um exemplo:
SINTAXE:
if (luminosidade < 500) {
Serial.println(“Luz acesa”);
else {
Serial.println(“Luz apagada”);
EXEMPLO:
int caixadagua = 48;
void setup()
{
52
Serial.begin(9600);
if (caixadagua <= 50) {// testa se a caixa está com menos

de 50% ou igual a 50%
/* Se a variável caixadagua estiver com menos de 50
exibe na tela a mensagem "A caixa está abaixo de 50%"*/
Serial.println("A caixa está abaixo de 50%");

}
else {/*Senão é printado na Serial a mensagem “A caixa
está acima de 50%” */
Serial.println("A caixa está acima de 50%");

}
}
void loop()
{
}
53
EXERCÍCIO 4
Desenvolva o projeto anterior, trocando a verificação de

luminosidade <=200 pela função else.
• Deve conter uma variável chamada luminosidade do

tipo int
• Deve conter uma variável chamada status do tipo
bool
• Deve verificar com o laço if se a variável
luminosidade é maior que 500, caso seja, deve fazer a
variável status receber false, e exibir a seguinte
mensagem na Serial: “A luz estah desligada”
• Deve verificar se a variável luminosidade é menor ou
igual a 200, caso seja verdadeiro, deve fazer a variável
status receber true, e exibir a seguinte mensagem na
Serial: “A luz estah ligada”.
• OBS: Lembre-se de não utilizar acentos ou caracteres
especiais nas mensagens da serial, pois ela pode não
entender,
54
(!) NOT
O operador lógico NOT, vem da lógica booleana, e serve

para invertermos o valor de uma lógica. Por exemplo: Se x
armazena um valor true, logo !x irá retornar um valor false, e o
mesmo vale para: se x armazena um valor false, então !x irá
retornar um valor verdadeiro.
O operador NOT, também pode ser usado em verificações

compostas como mostra abaixo:
SINTAXE:
!(x < y) // Se x for menor que y então o retorno será true,

porém acrescentando a lógica NOT à frente, esse valor é
invertido, se tornando false.
(&) AND
O operador AND é usado para comparar valores booleanos,

ele retorna true apenas quando dos os valores analisados forem
verdadeiros, e false nas demais possibilidades. Vamos aos
exemplos:
(true & true) //retorna true.
(true & false) //retorna false.
(false & true) // retorna false.
(false & false) // retorna false.
Ficou abstrato esse conceito? Vejamos um exemplo com if()
55
if((x < 20) & (y > 500)){} // Nesse caso o if() só será
executado quando x for MENOR QUE 20 e o y também for MAIOR
QUE 500. Em qualquer outra possibilidade ele não será
executado.
Também é possível fazer quantas comparações forem

necessárias, desde que seja atribuído o & em cada uma delas:
if((x < 20) & (y > 500) & (z == 0)){
(|) OR
Com o operador OR, quando qualquer verificação for

verdadeira, ele retorna verdadeiro, veja o exemplo:
(true | false) // retorna true
(false | true) // retorna true
(true | true) // retorna true
(false | false) // retorna false
Usando a lógica if():
If(x< 20 | y > 500 | z == 0) //Nesse caso se qualquer uma

das comparações for verdadeira, o if() será executado:
Se x for MENOR QUE 20, não importa se o y for menor que

500 ou o z diferente de 0, o if() será executado.
56
2.3 SAÍDAS DIGITAIS:
Ufa, bastante coisa certo? Mas há chegado a hora. Sim!

vamos começar a estudar as portas do Arduíno, e nesse capitulo
vamos criar os primeiros acionamentos.
Para podermos dar início, existem alguns conceitos que

você precisa ter em mente. Vou explica-los agora!
As portas do Arduíno, e também da grande maioria dos

microcontroladores, podem trabalhar tanto como entradas, e
também como saídas. Só depende exclusivamente da maneira
como você configura cada uma. A mesma porta pode trabalhar
como uma entrada, se configurada como INPUT, ou pode
trabalhar como uma saída caso configurada como OUTPUT.
O comando usado para fazer essa seleção dentro do

Arduíno é o pinMode, e sua utilização é bem simples, veja a
sintaxe abaixo:
SINTAXE:
pinMode(pino, tipo) // Pino deve conter a numeração ou

variável com o número do pino, e o tipo pode ser INPUT e
OUTPUT
pinMode(13, INPUT) // pino 13 definido como entrada
pinMode(13, OUTPUT) //pino 13 definido como saída
Dentro desse capitulo vamos estudar mais afundo como

funcionam as saídas, e no próximo capitulo vamos estudar as
entradas.
57
Vale deixar claro, que existem outros tipos de

configurações de portas, mas nesse momento, você precisa
apenas entender bem a fundo essas 2 maneiras.
Quando um pino é definido como saída, isso significa que

ele irá emitir um sinal de acionamento, ou seja, que ele irá passar
para o valor true, quando falamos de lógica. Ou se falarmos de
circuitos elétricos, significa que dentro do Arduíno, o pino
passará de 0v para 5v
Com isso, podemos acionar um LED, acionar um relé, uma

sirene, ou qualquer outra coisa que dependa de um acionamento
digital.
Gosto muito de uma frase que diz o seguinte:
“Se você consegue controlar um LED, você consegue

controlar qualquer coisa”
Essa frase é muito verdadeira, pois o mesmo acionamento

que é utilizado para acender um LED, pode ser utilizado para
executar uma infinidade de outras coisas.
Vamos aos exemplos:
Depois de selecionar o pino para OUTPUT, o comando

utilizado para fazer o acionamento de uma porta é o
digitalWrite(). Sendo que esse deve ter como parâmetro o pino
do acionamento e o valor que esse pino deve assumir, sendo a
escolha entre: LOW que indica que o pino está desligado, e HIGH
que indica que o pino está ligado. Vejamos a sintaxe:
58
SINTAXE:
digitalWrite(13, LOW) // pino 13 desligado
digitalWrite(13, HIGH) //pino 13 ligado
No exemplo abaixo, eu mostro como pode ser utilizado o

acionamento das saídas,
EXEMPLO:
void setup()
{
pinMode(4, OUTPUT);
}
void loop()
{
digitalWrite(4, HIGH); // Liga o LED
delay(1000); // Aguarda 1 segundo
digitalWrite(4, LOW); // Desliga o LED
}
Vamos colocar isso em prática, e se prepare pois esse será o

seu primeiro projeto.
Conforme combinamos no começo desse livro, durante o

seu caminho de aprendizado, haverá diversos projetos para
serem montados. Eu recomendo fortemente que você construa
esses projetos fisicamente, usando o Arduíno e os componentes
eletrônicos, porém, também é verdade que alguns deles podem
ser construídos usando simuladores online.
Todos os projetos tem a sua descrição, lista de

componentes, diagramas, e também o código fonte.
59
PROJETO#1 - Blink com LED
Nesse projeto vamos fazer um LED piscar com o Arduíno,

onde podemos controlar a velocidade com que o LED pisca.
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - LED 5mm
• 1 - 220 Ω Resistor
• Jumpers
Diagrama:
60
/* #1 – Blink com LED */
void setup()
{
pinMode(13, OUTPUT);
}
void loop()
{
digitalWrite(13, HIGH); // Liga o LED
digitalWrite(13, LOW); // Desliga o LED
}
/* Experimente mudar o tempo dentro do delay para ver a

velocidade em que o LED pisca mudar*/
61
EXERCÍCIO 5
Construa novamente o Projeto#1.
Dessa vez, armazenando o número do pino utilizado em

uma variável. Após isso utilize a variável como referência de
acionamento HIGH e LOW.
Veja o exemplo:
• int pinoLED = 13;

• pinMode(pinoLED, OUTPUT);
• digitalWrite(pinoLED, HIGH);
62
2.4 ENTRADAS DIGITAIS
Assim como eu expliquei no capítulo anterior, um pino

pode se comportar como saída, ou como entrada digital. Tudo
depende da maneira como você o configura usando o pinMode().
Uma entrada digital, tem o intuito de ler um sinal vindo de

um periférico externo; por exemplo: Imagine que você deseja
acionar uma lâmpada (saída digital), toda vez que escurecer.
Para saber quando escureceu, você pode usar um sensor digital,
e interliga-o no Arduíno. Então toda vez que o sensor enviar um
sinal digital para o Arduino, ele irá acionar a saída digital da
lâmpada.
Para lermos esse sinal vindo do sensor de luminosidade,

precisamos determinar um pino do Arduíno como uma INPUT,
dentro do pinMode.
Para se ler um sinal digital com um pino configurado como

entrada, basta usar o comando digitalRead(pino).
SINTAXE:
digitalRead(pino) // Onde pino, é a variável que contém o

número do pino, ou o número em si.
63
PROJETO#2 – Controlando um LED com um

botão:
Usando um Pushbutton para controlar o acionamento de

um LED.
O LED está conectado ao pino digital 13 do Arduíno e

acende quando o Pushbutton conectado ao pino 2 é pressionado.
* Nota: A maioria dos Arduínos já possui um LED integrado que

acende com o acionamento do pino 13.
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - LED 5mm
• 1 - 10K Ω Resistor
• 1 - Pushbutton
• Jumpers
Diagrama:
64
/* Constantes não mudam. Elas são usadas para setar os

números dos pinos*/
const int buttonPin = 2; // Pino do Pushbutton
const int ledPin = 13; // Pino do LED
// Variáveis que vão mudar:

int buttonState = 0; // Status do Pushbutton
void setup() {
// Inicializa o pino do LED como SAÍDA:

pinMode(ledPin, OUTPUT);
// Inicializa o pino do Pushbutton como ENTRADA:

pinMode(buttonPin, INPUT);
}
void loop() {
// Lê o status do Pushbutton
buttonState = digitalRead(buttonPin);
// Checa se o Pushbutton foi pressionado

// Se pressionado a variável buttonState muda para HIGH:
if (buttonState == HIGH) {
// Liga o LED:
digitalWrite(ledPin, HIGH);
} else {
// Desliga o LED:
digitalWrite(ledPin, LOW);
}
}
65
EXERCÍCIO 6
Execute novamente o Projeto#2.
Dessa vez, invertendo a lógica, fazendo com que o LED

fique aceso quando o botão está livre, e apague quando o botão
for pressionado.
OBS: Você precisa mudar a comparação dentro do laço if()
66
2.5 SWITCH-CASE
Imagine que você está desenvolvendo seus projetos, e se

depara com a seguinte situação: Você precisa fazer 10
verificações em uma variável, para fazer diversos acionamentos
dependendo do valor dela. Você vai usar 10 laços if() para fazer
essas verificações?
Pode ser que sim! Más, não é a melhor alternativa, pois

existe uma função chamada Switch-Case, que, assim como o if(),
controla o fluxo do programa, permitindo ao programador
especificar diversos códigos para serem executados em diversas
condições.
SINTAXE:
switch (variável) {
case valor1:
//executa um comando
break;
case valor2:
//executa outro comando
break;
case valor3:
//executa outro comando
break
67
EXEMPLO:
int Led1 = 7;
int Led2 = 8;
int Led3 = 9;
int Led4 = 10;
void setup() {
Serial.begin(9600);
pinMode(Led1, OUTPUT);
}
void loop() {
if (Serial.available()) {
char Led = Serial.read();
switch (Led) {
case '1':
digitalWrite(Led1, HIGH);
digitalWrite(Led2, LOW);
break;
case '2':
break;
case '3':
break;
case '4':
break;
default:
Serial.print("Valor ");
Serial.print(Led);
Serial.println(" incorreto.");
}
68
}
}
Assim como se você estivesse utilizando diversos laços if()

em sequência, o switch-case testa condição por condição, e caso
uma delas seja atendida é executado o código que está dentro.
Repare que logo após a execução do código, é necessário

utilizar o comando break, para que o Arduino entenda que
aquele comando acabou.
69
EXERCÍCIO 7
Crie novamente o Projeto#1, dessa vez utilizando 4 LEDs, e

faça com que cada LED acenda dependendo de caractere que
você enviar na Serial. Você pode tomar como base o exemplo
usado nesse capitulo. O exercício deve atender os seguintes
requisitos:
• Utilização de no mínimo 4 LEDs

• Deve-se usar variáveis para referenciar as pinagens
usadas nos LEDs,
• Deve-se usar o switch-case para acionar os LEDs
• Quando enviado o caractere ‘a’ deve-se acender o
primeiro LED e o restante permanecer apagado
• Quando enviado o caractere ‘b’ deve-se acender os
dois primeiros LEDs e deixar apagado o restante
• Quando enviado o caractere ‘c’ deve-se acender 3
LEDs e 1 ficar apagado
• Quando enviado o caractere ‘d’ deve-se acender todos
os LEDs
70
2.6 WHILE
Agora, vamos estudar um conceito muito importante

dentro da programação, que são os laços de repetição, e o
primeiro que vamos aprender é o while().
Mas afinal, pra que serve um laço de repetição? Nesse

momento você já deve ter entendido bem, que o void setup é
executado apenas uma vez quando o Arduino é ligado, já o void
loop é executado infinitamente enquanto o Arduino permanecer
ligado. Deixa-me te contar uma coisa:
O void loop nada mais é do que um while() escondido por

baixo dos panos. Vamos entender o seu funcionamento.
SINTAXE:
while(var) {// analisa se a variável é verdadeira (true)
//Enquanto a variável for true o laço é executado.
EXEMPLO:
void setup() {
Serial.begin(9600);
while (true) {
delay(2000);
}
}
void loop() {
71
Nesse exemplo o while será repetido infinitas vezes

enquanto o Arduíno permanecer ligado, mesmo estando dentro
da função setup(), isso por que eu coloquei o while(true)
diretamente dentro da verificação. A cada 2s será exibida a
mensagem “Hello World” na tela.
EXEMPLO:
int x = 0; //inicia uma variável x valendo 0
void setup() {
Serial.begin(9600); // instancia a Serial
}
void loop() {
while (x < 12) { // analisa se x é menor que 12
//Enquanto x for menor que 12 o laço é executado
Serial.print("X vale: "); //Exibe a mensagem x vale:

Serial.println(x); // Exibe o valor de x em frente a
string anterior
// O resultado é X vale: 1
// o valor de x aumenta uma unidade a cada vez que o
laço é repetido
// x recebe ele mesmo acrescido de 1 unidade

/*
Na primeira execução x vale 0, portanto x vai
receber 0 + 1
Na segunda execução x vale 1, portanto x vai
receber 1 + 1
Na segunda execução x vale 2, portanto x vai
receber 3 + 1
E assim por diante
*/
x = x + 1;
//delay de 2s
delay(2000);
//
}
}
O while() é executado repetidas vezes enquanto a variável

que está sendo analisada for igual a true, a cada iteração do ciclo
72
ele testa a variável para saber se ela ainda possui o valor

verdadeiro. Quando a variável se tornar false, o ciclo acaba e o
while() é interrompido.
73
EXERCÍCIO 8
Criar um algoritmo usando o while, que faça 50 iterações

com uma variável, e que exiba o valor dessa variável na Serial a
cada iteração:
• Você deve criar um algoritmo usando o while que conte de

0 a 50;
• A cada iteração deve ser exibida a seguinte mensagem: “O
valor da contagem e: “, seguido do valor da variável.
Exemplo:
• Na primeira iteração deve aparecer “O valor da contagem
e: 0”;
• Na segunda iteração deve aparecer “O valor da contagem e:
1”;
• E assim sucessivamente até que chegue a 50;
• Após a finalização da contagem deve ser exibida a
mensagem “Contagem Finalizada” na Serial, e também
deve ser aceso o LED integrado ao Arduíno no pino 13.
74
2.7 FOR
Além do while, outro laço de repetição muito utilizado é o

for(), porém sua diferença é que ele possui um momento para
começar, e um momento para terminar. Vejamos a sintaxe:
SINTAXE:
for (int i = 0; i < 50; i++) {
/* A variável i inicia com 0 e a cada ciclo é acrescido 1

unidade a ela, enquanto i for menor que 50 o for() é
executado, quando i for igual ou maior que 50 o for() acaba
*/
}
EXEMPLO:
void setup() {
}
void loop() {
for (int i = 0; i < 12; i++) {
// inicia uma contagem que vai de 0 a 11
Serial.print("O valor de i e: "); //para cada iteração

é exibido em tela a mensagem "O valor de i e "
//Após a string anterior é exibido o valor de i

Serial.println(i);
delay(500);
}
}
Dessa maneira o for() precisa de uma varável, o valor em

que ela vai começar, o valor em que ela vai terminar, e qual vai
ser o passo dessa variável.
75
O passo é quanto será acrescentado na variável a cada ciclo

do for().
Além disso, ele também pode ser usado para contagens

inversas, veja o exemplo:
EXEMPLO:
void setup() {
}
void loop() {
for (int i = 11; i > 0; i--) {
// inicia uma contagem que vai de 11 a 0
Serial.print("O valor de i e: "); //para cada iteração

é exibido em tela a mensagem "O valor de i e "
//Após a string anterior é exibido o valor de i

Serial.println(i);
}
}
Repare que ao invés de utilizar o i++, agora eu utilizei o i--,

o que significa que a cada iteração do for() o valor de i vai
diminuir 1 unidade.
Além disso, agora o i inicia em 11 e para quando for igual a

0.
76
EXERCÍCIO 9
Recriar o exercício do while, utilizando dessa vez o laço

for().
O exercício deve atender os mesmos requisitos do exercício

anterior.
• Você deve criar um algoritmo usando o for() que conte de 0

a 50;
Exemplo:
e: 0”;
1”;
77
EXERCÍCIO 10
Recrie o exercício anterior, dessa vez fazendo a contagem

inversa, iniciando em 50 e terminando em 0.
• Você deve criar um algoritmo usando o for() que conte de

50 a 0;
Exemplo:
e: 50”;
49”;
78
PROJETO#3 – Scrolling LED:
Esse projeto vamos acender 6 LEDs, 1 por vez fazendo um

efeito de scroll.
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 6 - LEDs 5mm
• Jumpers
Diagrama:
79
/*
Scrolling LED usando o laço for
Demonstra o uso do for() loop.

Múltiplos LEDs em sequencia
Sobre o circuito:
* LEDs ligados do pino 2 até o 7
*/
int timer = 100; // tempo
void setup() {
// usa o laço for para definir os pinos de saída
for (int thisPin = 2; thisPin < 8; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}
void loop() {
// loop do pino 2 até o 7
for (int thisPin = 2; thisPin < 8; thisPin++) {
// Liga o pino:
digitalWrite(thisPin, HIGH);
delay(timer);
// Desliga o pino
digitalWrite(thisPin, LOW);
}
// loop do pino 7 até o 2

for (int thisPin = 7; thisPin >= 2; thisPin--) {
// Liga o pino:
digitalWrite(thisPin, HIGH);
delay(timer);
// Desliga o pino:
digitalWrite(thisPin, LOW);
}
}
80
2.8 DO-WHILE
O do-while é exatamente igual ao while(), porem garante

que haverá ao menos 1 execução do laço antes que ele termine.
O código a ser executado deve ser colocado no do{} e após é

inserido o while com a condição. Caso a condição seja atendida o
while é repetido normalmente, caso contrário, o código segue o
fluxo de execução.
SINTAXE:
do {
//o que deve ser executado
} while(condição) //após ser executado 1 vez ele começa a

fazer as verificações
EXEMPLO:
int x = 2;
void setup() {
do {
Serial.println("Fui exibido 1 vez");
} while (x > 5); // Só será executado 1 vez pois x
é MENOR QUE 5
}
void loop() {
}
81
2.9 ENTRADAS ANALÓGICAS
Voltamos novamente a trabalhar com as portas do

Arduino, e dessa vez vamos analisar mais a fundo as entradas
analógicas, como usa-las e quando as usar
Uma entrada analógica serve para analisar sinais de

tensão. No caso do Arduino ele consegue processar sinais que
vão de 0 a 5v. Em outros controladores como a ESP32 por
exemplo, esse sinal vai de 0 a 3.3V.
Antes de estudarmos as variáveis analógicas efetivamente,

precisamos entender como elas funcionam, e pra isso você
precisa saber o que é um conversor A/D
CONVERSOR ANALÓGICO/DIGITAL
Em termos técnicos um conversor A/D é capaz de traduzir

um sinal continuo no tempo, para um sinal discretizado. Mas em
meio termo, isso quer dizer que ele é capaz de pegar um sinal
analógico de tensão ou corrente, e transformar isso em valores
digitais, capazes de serem entendidos pelo microcontrolador.
Na natureza nem tudo são flores, raramente iremos

encontrar uma variável diretamente em corrente ou sinal
elétrico. Geralmente precisamos traduzir os sinais do mundo
físico, para uma linguagem em que os computadores entendam.
Para um avião ler a pressão atmosférica, ele precisa de um

sensor que capte a pressão e converta isso em um sinal elétrico
para que o computador de bordo entenda.
82
Para um carro autônomo dirigir sozinho, ele precisa que as

imagens das câmeras e radares sejam convertidas em sinais
elétricos, para que ele entenda o trânsito e não cause acidentes.
SINTAXE:
analogRead(pino); // Sintaxe de leitura
int var = analogRead(pino); //Atribuição da leitura a uma

variável.
EXEMPLO:
int analogPin = A3; // Potenciômetro conectado ao pino A3
int val = 0; // variável para armazenar o valor lido
void setup() {
}
void loop() {
val = analogRead(analogPin);// Lê o pino
Serial.println(val); // imprime o valor lido na tela
}
83
PROJETO#4 – Controlando a frequência do

LED com potenciômetro:
Usando um potenciômetro para controlar a frequência em

que um LED pisca. A resistência do potenciômetro é lida,
aumentando ou diminuído a velocidade com que o LED pisca.
A velocidade em que o LED irá piscar, depende do valor lido

na função analogRead()
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - LED 5mm
• 1 - Potenciômetro 10k Ω (Modelo Trimpot)
• Jumpers
Diagrama:
84
int sensorPin = A0; // Pino de entrada do potenciômetro

int ledPin = 13; // Pino do LED
int sensorValue = 0;// Variável para armazenar o valor do
potenciômetro
void setup() {
// Declara o pino do LED como saída
pinMode(ledPin, OUTPUT);
}
void loop() {
// Lê o valor do potenciômetro
sensorValue = analogRead(sensorPin);
// Liga o LED
digitalWrite(ledPin, HIGH);
// Para o programa de acordo com o valor lido no
potenciômetro
delay(sensorValue);
// Desliga o LED
digitalWrite(ledPin, LOW);
// Para o programa de acordo com o valor lido no
potenciômetro
delay(sensorValue);
}
85
2.10 SAÍDAS ANALOGICAS
Você já ouviu falar em PWM? Se você nunca ouviu falar,

esse conceito pode parecer um pouco estranho pra você, mas vou
tentar simplificar ao máximo aqui, para seu entendimento.
Como você viu no capítulo anterior, os

microcontroladores, incluindo o Arduíno, permitem que você
faça leituras analógicas em suas portas. O que significa que ele
pega um sinal continuo, corta em vários pedacinhos, e
transforma isso em uma linguagem em que o processador
consiga entender.
Agora imagine o processo inverso. Sim! Esse mesmo

processo, totalmente invertido.
Quando falamos de saídas analógicas, significa que o

microcontrolador pega uma sequência de sinais e tenta
converter isso em um sinal analógico, ou seja continuo no
tempo. Por que eu usei a palavra “tenta”? Porque como já vimos
no capítulo anterior, o microcontrolador não entende a
linguagem física, então ele precisa usar dos recursos
disponíveis, para criar um sinal mais parecido com um sinal
físico real. Mas nenhum processador é perfeito, e quem
determina se a qualidade desse sinal vai ser boa ou ruim, é a
resolução dos microcontroladores. Vou citar aqui 2
microcontroladores para você entender melhor:
ARDUINO:
O Arduíno possuí uma resolução de 8 bits de saída, isso

quer dizer que os valores de saída podem variar de 0 a 255.
86
ESP32:
Esse microcontrolador possui um controle muito maior

que o Arduíno, e ele permite que varie a resolução de saída de 1 a
16 bits.
Pegando o exemplo do Arduíno, se pedirmos para ele

escrever um valor analógico em uma de suas saídas, usando o
comando analogWrite(), ele irá tentar replicar esse valor em
níveis de tensão. Isso se chama duty cicle, e é muito importante
você entender esse conceito. Vejamos o exemplo:
EXEMPLO:
Se você escrever 0 na saída, a tensão medida na porta é 0v
Se você escrever 255 na saída, a tensão medida na porta é

5V
Se você escrever na saída 128, a tensão medida é

aproximadamente 2.5V
Em outras palavras, o duty cicle é o tempo em que a porta

permanece ligada. Mas por que isso? Esse conceito envolve
eletrônica e eletricidade, mas basicamente a tensão em volts que
é medida em uma carga, nada mais é do que uma média de várias
tensões ao longo de um espaço de tempo.
Se o duty cicle é 0, significa que durante o período medido,

a porta permaneceu totalmente desligada
Se o duty cicle é 255, significa que durante o período

medido a porta permaneceu totalmente ligada
87
E se a duty cicle for 128? Isso aí, ele permaneceu

aproximadamente metade do tempo ligada, e metade do tempo
desligada.
A imagem abaixo mostra exatamente esse conceito:
Figura 6 – duty cicle.
Por que isso é importante para mim nesse momento? É que

usando o comando analogWrite(), você está controlando o duty
cicle da porta, e diretamente controlando a tensão de saída dessa
porta.
SINTAXE:
analogWrite(pino, valor)// pino é a numeração do pino a

ser controlado, e valor é o duty cicle.
EXEMPLO:
int ledPin = 9;// LED conectado ao pino digital 9
88
int analogPin = 3;// potenciômetro conectado ao pino

analógico 3
int val = 0;// variável para guardar o valor lido
void setup() {
pinMode(ledPin, OUTPUT); // configura o pino como saída
}
void loop() {
val = analogRead(analogPin);// lê o pino de entrada
analógica
analogWrite(ledPin, val / 4); // analogRead retorna
valores de 0 a 1023, analogWrite recebe de 0 a 255
}
89
PROJETO#5 – Controlando o brilho do LED

com PWM:
Usando o PWM vamos criar um algoritmo que irá

aumentar e diminuir a intensidade de brilho de um LED;
Esse efeito é chamado de fade.
Você pode identificar os pinos que permitem a saída

analógica no Arduíno com o símbolo de “~”. Como por exemplo:
~3, ~5, ~6, ~9.
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - LED 5mm //qualquer cor
• Jumpers
Diagrama:
90
/*
Fade
*/
int LED = 9; // O pino PWM que será usado

int brightness = 0;
int fadeAmount = 5;
void setup() {
pinMode(LED, OUTPUT); // declare pin 9 como SAÍDA
}
void loop() {
// seta o brilho do LED no pino 9 usando PWM
analogWrite(LED, brightness);
// Muda o brilho a cada iteração do loop

brightness = brightness + fadeAmount;
// Inverte o fade
if (brightness <= 0 || brightness >= 255) {
fadeAmount = -fadeAmount;
}
// aguarda 30 milissegundos
delay(30);
}
91
CAPITULO 3
3.1 VETORES
Quando conversamos sobre variáveis, entendemos que

uma variável nada mais é do que um pedaço de memória que o
Arduínos separa para que você guarde um dado. E os vetores não
deixam de ser variáveis, a diferença é que dentro de um vetor, é
possível guardar vários valores. Vamos fazer umas
comparações.
Dentro de uma variável int é possível guardar um número

certo?
Dentro de um char é possível guardar um caractere certo?
Imagine se você pudesse guardar vários números dentro de

uma única variável, ou guardar vários caracteres dentro de uma
variável. É pra isso que foi criado o vetor
SINTAXE:
int meusInts[6]; //Cria um vetor de 6 posições
int meusPinos[] = {2, 4 ,8, 6 } // cria um vetor vazio e atribui

cada inteiro em uma posição
char letras[3] = {‘a’, ‘b’, ‘c’} // cria um vetor de char de 3

posições e atribui cada letra em uma posição
Quando estamos trabalhando com vetores uma, coisa

precisa ficar bem clara, todo o vetor, é regido por índices. Se eu
armazenar 3 números dentro de um vetor, como vou acessar
cada um desses números depois?
92
Dessa maneira, a distribuição é feita por índices, onde a

primeira posição do vetor é o índice 0, a segunda posição é o
índice 1 e assim por diante. Voltamos ao exemplo anterior:
Se você criar o seguinte vetor:
vetor[3] = {250, 25, 5}
Nesse exemplo nós criamos um vetor de 3 posições, e na

primeira posição atribuímos o valor 250, na segunda posição o
valor 25, e na terceira posição o valor 5. Para acessar cada um dos
valores, você precisa usar a seguinte sintaxe:
Serial.println(vetor[0]) // Será exibido o valor 250
Serial.println(vetor[1]) //Será exibido o valor 25
Serial.println(vetor[2]) //Será exibido o valor 5
93
PROJETO#6 – Controlando LEDs em série

com potenciômetro:
Usando um potenciômetro, você pode controlar quantos

LEDs ficaram acesos ou apagados, dependendo da leitura
analógica vinda do potenciômetro.
O Arduíno irá controlar os LEDs em série, esse projeto pode

servir para qualquer desenvolvimento que você queira controlar
as saídas digitais baseando-se na leitura da entrada analógica
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - Potenciômetro
• 10 - LED 5mm
• Jumpers
Diagrama:
94
/*
Barra de LEDs
*/
// Variáveis que armazenam as pinagens e não vão mudar

const int analogPin = A0; // Pino que vai ler o
potenciômetro
const int ledCount = 10; // Numero de LEDs
int ledPins[] = {
2, 3, 4, 5, 6, 7, 8, 9, 10, 11
}; // Vetor que contem a pinagem dos LEDs em sequencia
void setup() {
// for para definir todos os pinos como SAÍDA
for (int thisLed = 0; thisLed < ledCount; thisLed++) {
pinMode(ledPins[thisLed], OUTPUT);
}
}
void loop() {
// Lê o potenciômetro
int sensorReading = analogRead(analogPin);
// função que converte o valor lido no número de LEDs:

int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
for (int thisLed = 0; thisLed < ledCount; thisLed++) {

// Se o item do vetor for menor que o ledLevel
// Liga o pino correspondente ao elemento

if (thisLed < ledLevel) {
digitalWrite(ledPins[thisLed], HIGH);
}
// Desliga todos os pinos que são maiores que ledLevel
else {
digitalWrite(ledPins[thisLed], LOW);
}
}
}
95
3.2 FUNÇÕES
Desde o começo desse livro você está lendo a palavra

função, e chegou o momento de desmistificar esse conceito.
Imagine que você precise escrever um algoritmo descreva

a rota para seu trabalho, ou uma receita de bolo. Você poderia
criar um algoritmo que diga: Ande duas quadras, vire à esquerda
depois a direita; ou então, adicione 2 colheres de açúcar, 3
xicaras de farinha, 2 ovos e então bata tudo.
Até aí tudo bem, vai funcionar perfeitamente. Agora e se

você precisasse escrever esse algoritmo várias vezes? Uma
maneira é você copiar toda a receita, ou toda a rota, e colar ela
várias vezes dentro do mesmo código.
Porém essa não é a maneira mais eficaz de se criar um

código que precisa se repetido várias vezes. Foi para isso que as
funções foram criadas.
Usando o exemplo da receita de bolo, bastaria você criar

uma função com a receita, e depois se precisasse repeti-la, ao
invés de se copiar a receita inteira várias vezes, é só pedir para
que a função seja executada várias vezes.
Isso encurta muito o tamanho dos nossos códigos, e facilita

muito a legibilidade do código.
Um algoritmo bem escrito, possui cada função bem

definida, para que o programador olhe para determinada
função, e já saiba exatamente o que ela está fazendo.
Assim como você olha para o void setup e já sabe que ele é
executado só uma vez.
96
E assim como você também olha para o void loop e sabe que
essa função se repete enquanto o Arduíno estiver ligado; as
funções que você criar devem ser bem autoexplicativas.
SINTAXE:
void nome_da_funcao () {
//código a ser executado
Para se chamar uma função basta colocar o nome dela com

parênteses: nome_da_funcao();
EXEMPLO:
void setup() {
pinMode(13, OUTPUT); // Define o pino 13 como saída
}
void loop() {
changeLights(); // Chama a função
// Quando a função é finalizada o código continua aqui.
delay(15000); /* Aguarda 15 segundos depois que função é

executada */
}
// Função
void changeLights() {
// Liga o LED
digitalWrite(13, HIGH);
// Aguarda 1 segundo com o LED ligado

delay(1000);
// Desliga o LED
digitalWrite(13, LOW);
// Aguarda 1 segundo com o LED desligado

delay(1000);
} // Fim da função, retorna para o loop.
97
PROJETO#7 - Arduino Controlando

Sinaleiro:
Construa um sinaleiro usando LEDs verde, vermelho e
amarelo
Componentes:
• 1 – Resistor de10k-ohm
• 1 – Pushbutton
• 3 – Resistor 220-ohm
• 1 – Protoboard
• Jumpers de conexão
• 1 – LED Vermelho
• 1 – LED Amarelo
• 1 – LED Verde
Diagrama:
98
int red = 10;

int yellow = 9;
int green = 8;
void setup() {
pinMode(red, OUTPUT);
pinMode(yellow, OUTPUT);
pinMode(green, OUTPUT);
}
void loop() {
changeLights();
delay(15000);
}
void changeLights() {
// Verde desligado, amarelo ligado por 3 segundos

digitalWrite(green, LOW);
digitalWrite(yellow, HIGH);
delay(3000);
// Desliga o Amarelo e liga o Vermelho por 5 segundos

digitalWrite(yellow, LOW);
digitalWrite(red, HIGH);
delay(5000);
// Desliga o Vermelho e liga o Verde

digitalWrite(yellow, LOW);
digitalWrite(red, LOW);
digitalWrite(green, HIGH);
delay(3000);
99
PROJETO#8 – Controlando um LED pela

luminosidade do ambiente:
Usando um Fotoresistor para controlar intensidade de

brilho de um LEDs de acordo com a quantidade de luz presente
no ambiente.
Um Fotoresistor é um componente que varia sua

resistência de acordo com a quantidade de luz que incide sobre o
mesmo. Vamos usar essa propriedade para controlar um LED.
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - LED 5mm
• 1 - 10K Ω Resistor
• 1 - Fotoresistor
• Jumpers
Diagrama:
100
// Constantes que armazenam as pinagens, para facilitar o

código
const int sensorPin = 0;

const int ledPin = 9;
// Vamos setar algumas variáveis globalmente

int lightLevel;
int calibratedlightLevel;
int maxThreshold = 0; // usado para setar o máximo de luz
int minThreshold = 1023; // usado para setar o mínimo de

luz
void setup()
{
pinMode(ledPin, OUTPUT);// Seta o pino do LED como SAÍDA
Serial.begin(9600);
}
void loop()
{
lightLevel = analogRead(sensorPin); // lê a porta
Serial.print(lightLevel);
//autoRange(); // executa a função autoRange
calibratedlightLevel = map(lightLevel, 0, 1023, 0,

255); //muda a escala de leitura de 0 a 1023 para 0 a 255
Serial.print("\t"); // imprime um tab

Serial.print(calibratedlightLevel);
analogWrite(ledPin, calibratedlightLevel); // Seta o
brilho do LED de acordo com o valor lido.
}
/*
Essa função seta o valor das variáveis minThreshold e
maxThreshold para o nível de luz do ambiente. Mova sua mão
em cima do sensor para calibrar.
O sensor irá perceber o range total de luz e vai
autocalibrar as entradas
*/
void autoRange()
{
if (lightLevel < minThreshold)
minThreshold = lightLevel;
if (lightLevel > maxThreshold)
101
maxThreshold = lightLevel;
// uma vez calibrado você pode inserir diretamente os

valores dentro da função map
lightLevel = map(lightLevel, minThreshold, maxThreshold,

0, 255);
lightLevel = constrain(lightLevel, 0, 255);
}
102
3.3 RETORNOS
Os retornos são um complemento para as funções. A

maioria das funções que estudamos até agora são void, ou seja,
elas não retornam nada, mas você pode criar funções que
retornam valores.
Você pode criar uma função que soma dois números e

retorna o resultado, ou ainda, você pode construir uma função
que diga se é dia ou noite, e retorne o status.
As possibilidades são gigantes, pois permite ainda mais a

segmentação dos códigos, vejamos a sintaxe:
SINTAXE:
int func_com_retorno(){ //definida que a função irá

retornar um int
//Executa algo
int a = 20; // cria uma variável com o valor 20
int b = 5; // cria uma variável com o valor 5
return a+b //soma a + b e retorna o valor
Temos algumas coisas para discutir aqui, repare que ao

invés de declarar a função como void, agora ela é do tipo int, isso
indica que o valor que ela irá retornar deve ser um inteiro. Assim
como uma variável precisa ter um tipo quando declarada, uma
função com retorno também precisa.
103
Segundo: para retornar o valor desejado, usa-se a sintaxe

return.
E por último, como acessar o valor retornado pela função?
Da mesma maneira que os valores são acessados dentro de

uma variável, veja:
Você pode exibir o valor retornado usando a Serial:
Serial.println(func_com_retorno());
Ou pode atribuir o valor retornado dentro de uma outra

variável:
int x = func_com_retorno();
Também é permitido utilizar qualquer um dos operadores

estudados:
int x = func_com_retorno() + 200;
if(func_com_retorno() <= 50){}
EXEMPLO
//experimente mudar esses valores para testar os resultados
int x = 50;
int y = 12;
void setup() {
int somatorio = soma(); // atribui o retorno da função na
variável somatorio
Serial.println(somatorio); //imprime o valor que foi
atribuido a variável somatorio
}
void loop() {
}
int soma() {
104
return x + y; //retorna a soma de x + y

}
105
PROJETO#9 – Lendo um sensor de

temperatura:
Medindo a temperatura do ambiente usando um sensor de

temperatura. Nesse projeto a temperatura será mostrada
usando a Serial do Arduíno.
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 1 – Sensor de Temperatura – TMP36
• Jumpers
Diagrama:
106
/*
Medindo temperatura com o sensor TMP36.

A saída de tensão do sensor é proporcional a temperatura
do ambiente, portanto basta converter o sinal de tensão em
leitura analógica apara calcular a temperatura
*/
const int temperaturePin = A0; // Le o sensor no pino A0
void setup()
{
Serial.begin(9600); // inicializa a Serial
}
void loop()
{
float voltage, degreesC, degreesF; //declara 3 variáveis
float, para o armazenamento da tensão, graus célsius e
graus Fahrenheit
voltage = getVoltage(temperaturePin); // mede a voltagem

no pino
degreesC = (voltage - 0.5) * 100.0; // converte tensão em

graus célsius
degreesF = degreesC * (9.0 / 5.0) + 32.0; //converte

graus celsius para Fahrenheit
// Imprime na serial a seguinte mensagem com os valores

// "voltage: 0.73 deg C: 22.75 deg F: 72.96"
Serial.print("voltagem: ");
Serial.print(voltage);
Serial.print(" Graus C: ");
Serial.print(degreesC);
Serial.print(" Graus F: ");
Serial.println(degreesF);
delay(1000); // Repete uma vez por segundo, (mude se

desejar)
}
float getVoltage(int pin) //Função para ler e retornar a

tensão
{
return (analogRead(pin) * 0.004882814);
107
// Outras coisas para testar com esse projeto:
// Ligar um LED se a temperatura exceder um valor
// Criar um termostato
108
3.4 PARÂMETROS
Ainda estudando sobre funções, existem os parâmetros

que podem ser usados dentro de uma função.
Imagine que você precise construir uma função que some

2 números, mas esses números existem fora da função.
Você pode resolver isso de 2 maneiras, sendo a primeira

declarando duas variáveis globais, e utilizando dentro da
função.
Ou passar essas variáveis por parâmetros dentro da

função.
SINTAXE:
void minha_fun(int x, int y){
return x + y;
//chamada da função:
minha_fun(45, 90); // o valor 45 é atribuído a x dentro da

função, e o valor 90 é atribuído a y dentro da função
109
3.5 CLASSES E BIBLIOTECAS
E nosso último objeto de estudos são as classes, mais

popularmente conhecidas como as bibliotecas ou libraries.
Mas afinal, o que é uma classe?
Deixe-me tentar ser o mais claro possível aqui: Imagine que

você criou uma programação para um Arduínos. Colocou ele
para rodar e funcionou da maneira que você gostaria. Depois de
algum tempo você percebe que se você usasse esse mesmo
código em outro projeto, você teria resultados bem melhores.
Assim como tudo até agora, você tem 2 maneiras de fazer isso.
Que é:
Abrir o código que você construiu e copia-lo para seu outro

projeto.
Ou você pode construir uma classe que contém as funções

que você precisa, e apenas importar essa classe no seu segundo
projeto. Ou seja, as classes assim como as funções, nos poupam
trabalho e extensas linhas de desenvolvimento.
Aumentando ainda mais esse exemplo, imagine que é

professor, e todos os seus alunos estão tendo dificuldades
justamente no problema que o código que você desenvolveu
resolve. Você vai passar o seu código individualmente para cada
aluno copiar? Pensando bem... É melhor construir uma
biblioteca que contém o código certo?
Graças ao mundo maker, temos desenvolvedores ao redor

do mundo que estão constantemente criando bibliotecas para
tudo o que você imaginar.
Biblioteca para ler sensor de temperatura: TEM!
Biblioteca para conexão com a internet: TEM!
110
E por isso é tão importante o fomento das comunidades

makers e open source.
Se você chegou até aqui, executou todos os exercícios e

projetos propostos, provavelmente em algum momento você já
se deparou com a seguinte sintaxe:
#include <AlgumNome.h>
Isso nada mais é do que uma importação de uma biblioteca.

Provavelmente dentro da biblioteca AlgumNome, exista alguma
função que você queira utilizar no seu código, e por isso precisa
informar ao Arduíno que você deseja importar tudo que existe
dentro dessa biblioteca, com o comando #include.
COMO INCLUIR BIBLIOTECAS
Com toda certeza, daqui pra frente você vai utilizar muito
essa ferramenta.
Como eu já expliquei, as bibliotecas servem para auxiliar, e

complementar o desenvolvimento. Com sua utilização, você
pode reaproveitar códigos, e inclusive até mesmo de outros
desenvolvedores.
Vou citar aqui o exemplo do Projeto#17 - DHT11 Sensor de

Temperatura e Umidade. Esse projeto é muito interessante, pois
é o projeto mais procurado no Google. Inclusive eu fiz uma aula
explicando como montar na prática, basta clicar AQUI .
Nesse projeto você vai precisar utilizar a biblioteca

“dht11.h”. Você pode encontrar ela disponível no Github
clicando AQUI.
Ao entrar no Github, você vai se deparar com a página

mostrada na figura 7:
111
Figura 7: Página de download da biblioteca, dentro do Github.
Para fazer o download da biblioteca, você precisa clicar no

botão verde “Clone or download”, e depois em “Download ZIP”.
Após isso será baixado um arquivo compactado com extensão
.zip para seu computador.
Além disso, você também vai precisar fazer o mesmo

procedimento com a biblioteca Adafruit Sensor, pois a DHT
depende dela.
Você pode baixa-la AQUI
Você irá precisar encontrar aonde esses arquivos foram

baixados em seu computador, e fazer a descompactação dos
mesmos.
112
Essa descompactação irá criar uma pasta. Dentro desta

pasta criada, você encontrará uma outra pasta que contém toda
a biblioteca. Você precisa copiar essa pasta que contem toda a
biblioteca para o diretório do Arduino\libraries no seu
computador. Na figura 8 você consegue ver o que existe dentro
da biblioteca “DHT11.h”. Cada arquivo desse tem uma função,
que colabora para que seu código funcione.
A criação de bibliotecas pode parecer um pouco

embaraçoso para você que está começando, portanto vamos nos
atentar aqui em aprender a usar as bibliotecas que já existem.
Figura 8: Conteúdo de uma biblioteca.
Você precisa copiar a pasta que contem todos esses

arquivos para o diretório que eu citei, assim como mostra a
figura 9, para que a IDE do Arduíno reconheça a biblioteca.
113
Figura 9: Pasta correta a copiada.
Em computadores com Windows, você possivelmente irá

encontrar o diretório do Arduíno em:
“D:\Documentos\Arduino”
Ou também:
“C:\Users\Mateus Dias\Documentos\Arduino”
É importante você encontrar esse diretório em seu

computador, pois é nele que vamos colar a biblioteca que
baixamos.
Dentro do diretório do Arduíno você deve encontrar algo

parecido com isso:
Figura 10: Pasta libraries aonde devem ser colocadas as

bibliotecas.
114
E é dentro desta pasta libraries que você deve colar todas as

bibliotecas que você precisar.
Automaticamente se uma biblioteca estiver contida dentro

da pasta libraries, a IDE do Arduíno irá reconhece-la.
OBS: Se você fez a instalação da IDE do Arduíno pelo Microsoft

Store. Eu recomendo fortemente que você remova essa
instalação, e baixe o instalador diretamente do site do Arduino
Isso por que quando a instalação é feita pela loja da

Microsoft, alguns diretórios podem ficar escondidos.
Dificultando deu aprendizado.
Após essa etapa de preparação você precisa abrir a IDE do

Arduíno, e construir o código conforme o projeto especifica.
Dentro da IDE você vai encontrar alguns botões, e vou

explicar o que cada um deles faz.
Figura 10 – Botões IDE
Em vermelho: Botão de compilação do código, é nele que

acionamos aquela espécie de “robô” que comentei a alguns
capítulos atrás. Com a verificação você consegue saber se está
tudo ok com seu código, antes de enviá-lo para o Arduíno.
Em alaranjado: Está o botão que faz o envio do código para

o Arduíno. Mesmo que você não tenha feito a compilação
manual antes de enviar, quando esse botão é pressionado ele
115
aciona o compilador, faz a verificação do código e após o término

da verificação ele faz o envio.
Seguindo, após o botão de envio, temos respectivamente o

botão de criar um novo projeto, o botão de abrir um projeto
existente, e o botão de salvar.
TRICK: Se você pressionar CTRL+T dentro da sua IDE, ela irá

fazer a formatação automática do código, deixando-o
organizado nos padrões do framework Arduino.
Com as teclas CTRL+S você consegue salvar o seu projeto.
Seu projeto deve ficar conforme o da figura 11:
Figura 11 – Código fonte Projeto#17
116
Para fazer a compilação do seu código, basta clicar no botão

verificar. E se tudo estiver correto você deve receber a seguinte
mensagem:
Figura 12: Compilação terminada com sucesso.
Isso significa que agora você já pode plugar o Arduíno no

seu computador e fazer o envio do código para dentro dele.
O procedimento de inclusão de bibliotecas é o mesmo para

qualquer biblioteca que você precisar. Fazer o download,
descompactar, colar dentro da pasta libraries dentro do diretório
do Arduino, e sair usando.
Vou te mostrar agora algumas coisas que podem te ajudar.
A grande maioria das bibliotecas vem com exemplos

incluídos, para você conseguir se basear em seus projetos. Após
seguir o procedimento para incluir a biblioteca, você pode
encontrar os exemplos da mesma, seguindo os passos:
Abra a IDE -> Arquivo -> Exemplos -> Nome da biblioteca
A figura 13 mostra o passo a passo.
Além disso nesse menu, você pode encontrar diversos

outros exemplos que a própria Arduino disponibiliza para te
auxiliar.
117
Figura 13 – Exemplos embutidos em bibliotecas.
Existe também uma segunda maneira de se adicionar

bibliotecas dentro da IDE do Arduino. Porém não recomendo,
pois não são todas as bibliotecas que você encontra nesse
método.
Ao pressionar CTRL+SHIFT+I em seu teclado, deve abrir o

gerenciador de bibliotecas do Arduino, conforme a figura 14, e
dentro do mesmo, você consegue fazer uma busca por
bibliotecas que necessita. Mas como eu disse, não são todas as
bibliotecas que estão dentro desse gerenciador. Por vezes você
irá precisar seguir o método manual que eu ensinei você.
Figura 14 – Gerenciador de bibliotecas.
118
PROJETO#10 – Posicionamento com GPS

NEO-6M
Usando um módulo GPS podemos receber o

posicionamento do Arduino em tempo real, e visualizar a
latitude e longitude através da Serial.
Esse projeto é um exemplo de como a comunicação Serial
pode ser usada com outro dispositivo fora do computador.
Iremos criar um a comunicação Serial com o computador, e
outra comunicação Serial com o GPS
Componentes:
• 1 - Arduino UNO
• 1 – Módulo NEO-6M GPS
• Jumpers
Diagrama:
119
#include <SoftwareSerial.h> //Inclui a biblioteca

SoftwareSerial.h. Não precisa baixar externamente, pois
essa biblioteca já vem junto com o pacote da IDE
// Serial usada para se comunicar com o módulo

SoftwareSerial ss(4, 3);
void setup() {
Serial.begin(9600); //inicia a Serial com o computador
ss.begin(9600); //Inicia a Serial com o GPS
}
void loop() {
while (ss.available() > 0) {
// Le os dados do GPS
byte gpsData = ss.read();
Serial.write(gpsData);
}
}
120
PROJETO#11 – Tocando uma melodia com

buzzer:
Nesse projeto vamos tocar uma pequena melodia usando

o Arduíno e um piezo buzzer/speaker.
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - Piezo Buzzer
• Jumpers
Diagrama:
121
/*
circuito:
8-ohm buzzer conectado no pino digital 8
*/
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_A3 220
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
122
#define NOTE_A4 440

#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_D5 587
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_G5 784
#define NOTE_A5 880
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_D6 1175
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_G6 1568
#define NOTE_A6 1760
#define NOTE_B6 1976
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_G7 3136
#define NOTE_A7 3520
#define NOTE_B7 3951
// cria um vetor de notas

int melody[] = {
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3,
NOTE_C4
};
123
// duração das notas

int noteDurations[] = {
4, 8, 8, 4, 4, 4, 4, 4
};
void setup() {
for (int thisNote = 0; thisNote < 8; thisNote++) {
int noteDuration = 1000 / noteDurations[thisNote];

tone(8, melody[thisNote], noteDuration);
int pauseBetweenNotes = noteDuration * 1.30;

delay(pauseBetweenNotes);
// para a música
noTone(8);
}
}
void loop() {
124
PROJETO#12 – Controlando um servo:
Nesse projeto vamos controlar um microservo modelo 9g

usando o Arduíno.
OBS: teste apenas com 1 microservo 9g pois o Arduino não

possui corrente o suficiente para alimentar mais de 1, ou servos
maiores.
Componentes:
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - Servo
• Jumper
Diagrama:
125
#include <Servo.h> // Inclui a biblioteca do servo
Servo servo1; // cria o objeto do servo
void setup()
{
servo1.attach(9, 900, 2100); //conecta o servo no pino 9
//com o valor mínimo de PWM
//900 e o valor máximo de PWM
//2100.
void loop()
{
int position;
// Para controlar o servo você precisa do angulo de
posição
// Ele não pode ser movido 360°
// Você pode move-lo de 0 a 180°
// A posição muda em velocidade máxima
servo1.write(90); // manda o servo ir para 90°
delay(1000); // Pausa
// manda o servo se movimentar 180° pulando 1 grau de

cada vez
for (position = 0; position < 180; position += 1)

{
servo1.write(position); // move para a próxima posição
delay(20); // pequena pausa antes de se movimentar
novamente
}
// manda o servo se movimentar 180° pulando 1 grau de cada

vez
for (position = 180; position >= 0; position -= 1)
{
servo1.write(position);
delay(20);
}
}
126
PROJETO#13 – Controlando um motor DC:
Usando um transistor, nós podemos controlar um motor

DC com corrente superior à que o Arduino suporta, isso por que
o transistor funciona como uma válvula que regula o quanto de
corrente flui da fonte para o motor.
Componentes
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - Motor DC
• 1 - Diodo 1N4148
• 1 - NPN Transistor
• Jumpers
Diagrama
127
/*
Esse exemplo exige o uso de um transistor operando como
chave. O Arduino permite apenas 40mA de corrente em suas
portas, o que não é suficiente para acionar um motor DC,
que necessita no mínimo 150mA
*/
const int motorPin = 9; // conecte a base do transistor no

pino 9.
// Não conecte o pino diretamente no motor
void setup()
{
pinMode(motorPin, OUTPUT); // seta o pino como saída
Serial.begin(9600); // inicializa a Serial
}
void loop()
{/* Esse exemplo basicamente replica o Blink substituindo o
LED por um motor DC.*/
int onTime = 3000; // tempo para o motor ligar

int offTime = 3000; // tempo para o motor desligar
analogWrite(motorPin, 255); // liga o motor (velocidade

máxima)
delay(onTime); // delay
analogWrite(motorPin, 0); // desliga o motor
delay(offTime); // delay
// remova as // para ativar as funções

// speedUpandDown();
// serialSpeed();
}
// essa função acelera o motor até a velocidade máxima

// então desacelera até ele parar
void speedUpandDown()
{
int speed;
int delayTime = 20; // milissegundos para cada passo
// acelera o motor
for (speed = 0; speed <= 255; speed++)
{
analogWrite(motorPin, speed); // seta a nova velocidade
delay(delayTime); // delay entre os passos
}
// desacelera o motor
for (speed = 255; speed >= 0; speed--)
{
128
analogWrite(motorPin, speed); // seta a nova velocidade

delay(delayTime); // delay entre os passos
}
}
// Entra a velocidade entre 0 e 255 na Serial

void serialSpeed()
{
int speed;
Serial.println("Digite uma velocidade entre 0 e 255");

Serial.println(); // imprime uma linha em branco
while (true) //loop “para sempre”

{
// Checa se existe alguma informação na Serial
while (Serial.available() > 0)
{
speed = Serial.parseInt(); // lê o valor inteiro
digitado na Serial.
speed = constrain(speed, 0, 255);
Serial.print("Velocidade setada: "); // feedback

Serial.println(speed);
analogWrite(motorPin, speed); // seta a velocidade do

motor.
}
}
}
129
PROJETO#14 – Display LCD:
Um LCD é um display de cristal líquido que permite

escrever texto no display.
Nesse projeto você vai conseguir escrever a String “Hello

World” no display.
Nesse projeto também será acrescentado um

potenciômetro para ajustar o contraste do display.
Componentes
• 1 - Arduino Uno
• 1 - Protoboard
• 1 - Display LCD
• 1 - Potenciômetro
• Jumpers
Diagrama
130
/*
LIQUID CRYSTAL DISPLAY (LCD)
Um LCD é um display de cristal líquido, é um modulo

sofisticado que pode exibir texto e dados numéricos.
Esse modelo de display pode exibir até 16 caracteres, e
possui luz de fundo (backlight).
Se você já construiu alguns projetos usando o Serial

Monitor, o display LCD vai prover diversos benefícios pros
seus desenvolvimentos.
Esse projeto demonstra como você pode ligar um LCD em seu

Arduíno e mostrar qualquer dado que você quiser.
*/
// Carrega a biblioteca do LCD

// A biblioteca trás funções de comando LCD
#include <LiquidCrystal.h>
// Inicializa a biblioteca com os pinos que você está

utilizando.
// Nota: Você pode utilizar pinos diferentes
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
lcd.begin(16, 2); //Inicializa o LCD 16x2

lcd.clear(); // Limpa o LCD
lcd.print("Hello, World!"); // Imprime Hello, World!
void loop()
{
lcd.setCursor(0, 1); //Seta o cursor na coluna 0,
linha 1.
lcd.print(millis() / 1000); //Imprime o número de
segundos desde que o Arduíno foi ligado.
}
131
PROJETO#15 - DHT11 Sensor de

Temperatura e Umidade
Esse projeto será capaz de construir um medidor de

temperatura e umidade usando o sensor DHT11.
Nesse projeto você vai precisar utilizar a biblioteca

“dht11.h”. Você pode encontrar ela disponível no Github
clicando AQUI.
Também irá precisar da biblioteca Adafruit Sensors. Você pode

baixa-la AQUI
Componentes
• 1 - Arduino UNO
• 1 - DHT11 sensor de temperatura e umidade
• 1 - Protoboard
• 1 - 4.7k Ohm Resistor
• Jumpers
Diagrama:
132
// importa a biblioteca DHT11

#include "DHT.h"
#define DHTPIN 2 //Define o pino para ser conectado
// descomente a linha do modelo do sensor.

#define DHTTYPE DHT11 // DHT 11
//#define DHTTYPE DHT22 // DHT 22 (AM2302)
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Inicializa o sensor
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(9600);
Serial.println("DHTxx teste!");
dht.begin();
}
void loop() {
// Aguarda 2 segundos para a medição
delay(2000);
// Lê a umidade
float h = dht.readHumidity();
// Lê temperatura como celcius
float t = dht.readTemperature();
// Lê temperatura como Fahrenheit
float f = dht.readTemperature(true);
Serial.print("Umidade: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperatura: ");
Serial.print(t);
Serial.print(" *C ");
Serial.print(f);
Serial.print(" *F\t");
}
133
PROJETO#16 - Arduino com sensor de

movimento PIR
Montando um sensor de movimento usando um sensor de

movimento HC-SR501 (PIR).
Componentes:
• 1 - Arduino UNO
• 1 - PIR Motion Sensor (HC-SR501)
• 1 - LED
• Jumpers
Diagrama:
134
int led = 13; // pino de conexão do LED

int sensor = 2; // pino do sensor
int state = LOW; // por padrão o sensor fica em LOW
int val = 0; // variável para armazenar o status do sensor
void setup() {
pinMode(led, OUTPUT); // inicializa o LED com SAÍDA
pinMode(sensor, INPUT); // inicializa o sensor como
ENTRADA
Serial.begin(9600); // inicializa a serial
}
void loop() {
val = digitalRead(sensor); // lê o sensor
if (val == HIGH) {// checa se o sensor está em HIGH
digitalWrite(led, HIGH); // liga o LED

delay(100); // delay de 100 milissegundos
if (state == LOW) {
Serial.println("Movimento detectado!");
state = HIGH; // faz o update da variável para HIGH
}
}
else {
// caso não seja detectado movimento
digitalWrite(led, LOW); // desliga o LED
delay(200); // delay de 200 milissegundos
if (state == HIGH) {
Serial.println("Sem movimento detectado!");
state = LOW; // muda a variável para LOW
}
}
}
135
PROJETO#17 – Analise de solo com YL-69 ou

HL-69:
Criando um dispositivo para análise de umidade de solo, e

controlando LEDs para o solo ideal.
Componentes
• 1 - Arduino UNO
• 1 - YL-69 sensor de umidade de solo
• 1 - Protoboard
• 2 - 220 Ohm Resistor
• 1 – LED Vermelho
• 1 – LED Verde
• Jumpers
Diagrama
136
int rainPin = A0; // Pino do sensor

int greenLED = 6; // Pino do LED verde
int redLED = 7; // Pino do LED vermelho
// você pode ajustar o setpoint

int thresholdValue = 800;
void setup() {
pinMode(rainPin, INPUT); // seta o sensor como ENTRADA
pinMode(greenLED, OUTPUT); // LED verde como SAÍDA
pinMode(redLED, OUTPUT); // LED vermelho como SAÍDA
digitalWrite(greenLED, LOW); // LED verde inicia em LOW
digitalWrite(redLED, LOW); // LED vermelho inicia em LOW
}
void loop() {
// Lê a entrada no pino 0
int sensorValue = analogRead(rainPin);
Serial.print(sensorValue);
if (sensorValue < thresholdValue) {
Serial.println(" – Nao precisa de agua");
digitalWrite(redLED, LOW);
digitalWrite(greenLED, HIGH);
}
else {
Serial.println(" – Hora de regar sua planta");
digitalWrite(redLED, HIGH);
digitalWrite(greenLED, LOW);
}
delay(500);
}
137
IGNIÇÃO
Primeiro gostaria de lhe dar os parabéns por ter concluído

todos os exemplos, exercícios e todos os projetos.
Agora você já tem o direcionamento, e a bagagem de

conhecimento para construir seus próprios projetos.
Sinta-se à vontade para consultar esse livro quantas vezes

forem necessárias durante a sua jornada. Lembre-se também
que deixei o Arduino Blueprint de presente para você, que
também irá te auxiliar muito.
Cada capitulo você aprendeu funcionalidades novas, que te

deram o direcionamento para continuar evoluindo como
desenvolvedor.
O importante é treino, pratica e consistência.
A partir daqui você pode buscar novos projetos para

construir, e vou deixar de recomendação alguns lugares aonde
você pode conseguir bons projetos:
Arduino Project Hub : https://create.arduino.cc/projecthub
Lobo da Robótica Blog: https://lobodarobotica.com/
Fritzing Projects : https://fritzing.org/projects/
Sempre que você construir um projeto novo, me marque no

Instagram para eu acompanhar sua evolução.
Ficarei feliz em ver que fiz parte do seu processo de

aprendizado.
138
Quando sentir-se desafiado a dar próximo passo. Convido

você para se ajuntar comigo em mais uma jornada:
• Construção de projetos que se integrem com a

internet.
• Profissionalização de projetos usando controle de
código e gerenciador de branchs, com o Github e
Bitbucket.
• Jira e plataformas Kanban.
• Programação de dispositivos via redes wireless
(OTA).
• Interfaces de programação avançadas.
• Computação em nuvem.
• Protocolos de comunicação web.
• Interfaces web.
• Banco de dados voltados para IoT.
• Programação em multi-núcleos RTOS.
“Tudo parece impossível até que seja feito”
Vejo você em breve - Mateus D. Dias
Todos os direitos reservados – Lobo da Robótica 2020
139

Ardu Hack

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Ardu Hack

Enviado por

Direitos autorais:

Formatos disponíveis

Licensed to ALCEU DOMINGUES ALVES - aaalllceu@yahoo.com.

Mateus D. Dias é formado em Engenharia de Controle e

Trabalhando na área, viu o déficit de profissionais, por isso

Atualmente possui um projeto para ensinar

Blog Lobo da Robótica:

Acesso ao Minicurso BÔNUS:

Dedico esse livro primeiramente a Deus por me permitir

POR QUE ESCREVI ESSE LIVRO

Diariamente recebo pedido de pessoas que querem

Veja bem, não há nada de errado em copiar projetos de

Uma criança aprende a falar, imitando as palavras dos pais,

Cada capitulo deste livro foi projetado de maneira

Cada projeto foi pensado e construído para colocar em

SUBTRAÇÃO UNITÁRIA (--) .................................................... 42

PROJETO#13 – CONTROLANDO UM MOTOR DC: ................... 127

KIT ARDUINO COMPLETO LOBO DA ROBÓTICA

Muitos dos projetos desse e-book, eu irei ensinar como

Por esse motivo, montei um kit completo com o maior

Mateus, esse kit possui tudo o que preciso para construir

A resposta é não, pois o livro possui dezenas de projetos,

O Kit Arduino completo Lobo da Robótica, possui os

Conheça mais através do link:

Agora que já nos conhecemos, está na hora de conhecer

Com certeza a melhor maneira de se aprender é

“Imagine que você está em um caiaque, e você tem 2 remos

Assim que você aprender algo novo nesse livro, vá e

Esse livro está dividido em explicações e exercícios, então a

Em cada capitulo eu irei explicar sobre um conceito novo

suas próprias aplicações sozinho, de forma cada vez mais

0.2 ARDUÍNO BLUEPRINT

Como bônus eu vou estar disponibilizando pra você o

1.1 COMO FUNCIONA A PROTOBOARD?

A primeira coisa que você precisa entender antes de sair

Essa placa cheia de furos pode parecer estranha, mas

Você precisa ter em mente que a protoboard é utilizada

A figura 1 mostra como as furações da protoboard estão

Já as laterais da protoboard, são usadas basicamente para

A protoboard da imagem, é dividida em 6 regiões conforme

Figura 2 – Região de ligações.

Cada região demarcada em vermelho está isolada das

Mais à frente, iremos construir circuitos usando a

1.2 CONVERSANDO COM O ARDUINO

Se você me perguntar se é possível, “conversar com o

Nesse capitulo vamos estudar mais sobre a Serial, e como

A Serial é uma função nativa presente no Arduíno, que

Com a Serial é possível enviar informações do computador

A sintaxe de utilização é bem simples, basta inserir na

As coisas começaram a complicar? Parâmetro? Função?

As velocidades de comunicação mais comuns de serem

Supondo que desejamos que, ao ligar o Arduíno, ele nos

Já sabemos que o Serial.begin(9600) tem que estar

A função Serial.print, é capaz de enviar um texto do

Apareceram duas funções aqui, void setup() e void loop(),

Repare também que existe a seguinte linha no código:

//configura a comunicação serial com baud rate de 9600

Essa é uma linha de comentário, ou seja, ela é ignorada pelo

Você também pode indicar que deseja escrever várias

/* Eu sou um comentário de várias linhas, e sirvo para

//configura a comunicação seria com baud rate de 9600

Você pode testar esse código no seu Arduíno, ou pode

Mas, muita atenção, até o momento em que publico esse

Ao executar o código do exemplo, a saída que você deve