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
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
REVISÃO 2.0
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:
Canal do Telegram:
https://t.me/canallobodarobotica
Instagram:
https://www.instagram.com/lobodarobotica/
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
Blog Lobo da Robótica:
https://lobodarobotica.com/blog
Canal no Youtube:
https://lobodarobotica.com/canal-yt
Página do Facebook:
https://www.facebook.com/lobodarobotica/
Acesso ao Minicurso BÔNUS:
https://lobodarobotica.com/acesso-minicurso
E-mail:
suporte@lobodarobotica.com
2
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
POR QUE ESCREVI ESSE LIVRO
Diariamente recebo pedidos 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
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
SUMÁRIO
REVISÃO 2.0 .......................................................................................1
SOBRE O AUTOR: ........................................................................1
DEDICATÓRIA ....................................................................................3
POR QUE ESCREVI ESSE LIVRO ....................................................4
KIT ARDUINO COMPLETO LOBO DA ROBÓTICA.....................8
TREINAMENTO COMPLETO DE ARDUINO ...............................9
CAPITULO 0 ......................................................................................13
0.1 APRESENTAÇÃO .......................................................................13
0.2 ARDUÍNO BLUEPRINT ..............................................................15
CAPITULO 1 ......................................................................................16
1.1 COMO FUNCIONA A PROTOBOARD?.....................................17
1.2 CONVERSANDO COM O ARDUINO.........................................19
EXERCÍCIO 1 ..............................................................................25
1.3 VOID LOOP E VOID SETUP ......................................................26
1.4 ARMAZENANDO INFORMAÇÕES COM VARIÁVEIS ..............27
CONTEXTO DE VARIÁVEIS.......................................................30
#DEFINE E CONSTANTES ........................................................32
EXERCÍCIO 2 ..............................................................................35
1.5 OPERADORES ARITMÉTICOS – FAZENDO CÁCULOS
DURANTE A PROGRAMAÇÃO .......................................................36
ATRIBUIÇÃO (=) .........................................................................36
ADIÇÃO (+) ..................................................................................37
SUBTRAÇÃO (-) ..........................................................................39
MULTIPLICAÇÃO (*) ...................................................................40
DIVISÃO (/) ..................................................................................42
RESTO (%) ..................................................................................44
SOMA UNITÁRIA (++) .................................................................45
SUBTRAÇÃO UNITÁRIA (--).......................................................46
CAPITULO 2......................................................................................47
5
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
2.1 OPERADORES LÓGICOS E DE COMPARAÇÃO ....................47
(==) IGUAL A: ..............................................................................47
(>) MAIOR QUE ...........................................................................48
(<) MENOR QUE .........................................................................48
(<=) MENOR IGUAL ....................................................................48
(>=) MAIOR IGUAL: .....................................................................49
(!=) DIFERENTE ..........................................................................49
2.2 SE (EU ESTUDAR O ARDUHACK) {VOU FAZER PROJETOS
CADA VEZ MELHORES} ..................................................................51
EXERCÍCIO 3: .............................................................................55
EXERCÍCIO 4 ..............................................................................58
(!) NOT .........................................................................................59
(&) AND ........................................................................................59
(|) OR ............................................................................................60
2.3 SAÍDAS DIGITAIS: ......................................................................61
PROJETO#1 - Blink com LED ..........................................................64
EXERCÍCIO 5 ..............................................................................66
2.4 ENTRADAS DIGITAIS ................................................................67
PROJETO#2 – Controlando um LED com um botão: ......................68
EXERCÍCIO 6 ..............................................................................70
2.5 SWITCH-CASE ...........................................................................71
EXERCÍCIO 7 ..............................................................................74
2.6 WHILE .........................................................................................75
EXERCÍCIO 8 ..............................................................................78
2.7 FOR .............................................................................................79
EXERCÍCIO 9 ..............................................................................81
EXERCÍCIO 10 ............................................................................82
PROJETO#3 – Scrolling LED: ..........................................................83
2.8 DO-WHILE ...................................................................................85
2.9 ENTRADAS ANALÓGICAS ........................................................86
6
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
CONVERSOR ANALÓGICO/DIGITAL ........................................86
PROJETO#4 – Controlando a frequência do LED com
potenciômetro: ...................................................................................88
2.10 SAÍDAS ANALOGICAS ............................................................90
PROJETO#5 – Controlando o brilho do LED com PWM: ................94
CAPITULO 3......................................................................................96
3.1 VETORES ...................................................................................96
PROJETO#6 – Controlando LEDs em série com potenciômetro: ...98
3.2 FUNÇÕES ................................................................................ 100
PROJETO#7 - Arduino Controlando Sinaleiro: ............................. 102
PROJETO#8 – Controlando um LED pela luminosidade do
ambiente: ........................................................................................ 104
3.3 RETORNOS ............................................................................. 107
PROJETO#9 – Lendo um sensor de temperatura: ....................... 110
3.4 PARÂMETROS ........................................................................ 113
3.5 CLASSES E BIBLIOTECAS .................................................... 114
COMO INCLUIR BIBLIOTECAS .............................................. 115
PROJETO#10 – Posicionamento com GPS NEO-6M .................. 123
PROJETO#11 – Tocando uma melodia com buzzer: ................... 125
PROJETO#12 – Controlando um servo: ....................................... 129
PROJETO#13 – Controlando um motor DC:................................. 131
PROJETO#14 – Display LCD: ....................................................... 134
PROJETO#15 - DHT11 Sensor de Temperatura e Umidade ....... 136
PROJETO#16 - Arduino com sensor de movimento PIR ............. 138
PROJETO#17 – Analise de solo com YL-69 ou HL-69:................ 140
IGNIÇÃO......................................................................................... 142
7
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
número 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
8
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
TREINAMENTO COMPLETO DE ARDUINO
Desde que lancei a primeira versão desse livro, ele já ajudou
milhares de pessoas a transformarem ideias em projetos usando
o Arduino.
Parece até engraçado, mas a história é sempre a mesma, e
cheguei a fazer as contas pra te trazer em números aqui: 7 a cada
10 pessoas que leem este livro me contatam pedindo aulas em
vídeo.
Depois de milhares de pedidos, finalmente o conteúdo
desse ebook virou um treinamento.
No momento em que escrevo essa revisão, já são mais de
50 aulas em vídeo disponíveis na plataforma, e com certeza é
só o começo, pois nessa área, não da pra ficar parado.
Meu objetivo com esse treinamento, é te pegar pela mão e
te ensinar tudo o que eu sei sobre Arduino, lógica de
programação e eletrônica.
9
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
Mas é claro que isso não é tudo...
Junto com esse treinamento, você recebe diversos bônus
que fazem total diferença na hora do aprendizado.
Veja alguns deles:
•
Acesso aos grupos Exclusivos do Telegram,
WhatsApp e Facebook
•
•
•
Módulo de Shields e Extensões do Arduino
Módulo de Eletrônica Aplicada
Certificado de Conclusão
Bom, vamos lá, vou comentar cada um desses bônus com
você, e começando pelo que na minha opinião, faz esse
treinamento ser um diferencial na sua vida: Os Grupos
Exclusivos.
De todos as avaliações que recebo desse treinamento, o que
mais elogiam é os grupos exclusivos, e principalmente o Grupo
do WhatsApp.
Isso por que não são simplesmente grupos, e sim tenho
orgulho de dizer que formamos uma comunidade. Onde todos
estão engajados com o mesmo objetivo.
Todos estamos dispostos a ajudar e serem ajudados, e é isso
que torna esses grupos tão especiais.
10
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
E como prova disso vou deixar aqui um print com um
depoimento que um aluno me mandou:
E como você pode ver, nas palavras dele, só os grupos já
pagam o valor investido.
Os outros bônus que também podem te ajudar na sua
jornada, são os módulos de eletrônica aplicada e de Shields,
nesses módulos vamos estudar a fundo a eletrônica, e como usala na criação dos seus projetos.
Além de que vamos estudar também todos as Shields e
extensões que o Arduino possui, e em cada uma dessas aulas vou
te dar ideias de como você pode estar utilizando em seus
projetos.
E, além de tudo isso, você também tem acesso ao
certificado de conclusão. Que pode alavancar sua carreira,
complementar sua faculdade ou apenas de dar a satisfação de ter
concluído mais essa etapa em sua vida.
11
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
Ainda preciso te lembrar de que você tem 7 dias de garantia
total sobre o Curso, então você investindo nesse treinamento, e
por qualquer motivo que seja, você desistir da sua vaga, basta
você me encaminhar um e-mail que eu estorno 100% do valor
investido.
Faça parte desse treinamento e dessa comunidade através
do link abaixo:
https://lobodarobotica.com/treinamento-arduhackcompleto
12
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
13
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
suas próprias aplicações sozinho, de forma cada vez mais
profissional.
14
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
15
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
CAPITULO 1
Durante essa jornada você vai precisar de alguns
softwares, que vão te auxiliar e facilitar muito seu aprendizado.
Eu já vou deixar a indicação para você aqui, para que assim
que tenhamos que utilizar, você já tenha preparado tudo.
O primeiro deles, é um simulador de eletrônica e Arduino,
chamado TinkerCAD, ele funciona totalmente online, e não
precisa instalar nada no seu computador, apenas acessar o site e
criar um conta. Eu falo um pouco mais sobre ele no minicurso
bônus desse ebook. Pra você acessar e criar uma conta basta
entrar pelo link abaixo:
https://www.tinkercad.com/
O segundo software que mais vamos utilizar é a IDE do
Arduino, vamos utiliza-la pra fazer a gravação dos nossos
algoritmos nas placas.
Não se preocupe agora em entender o que cada um faz,
vamos estudar isso mais pra frente, mas eu recomendo que você
já deixe tudo preparado agora.
Esse software, diferente do TinkerCAD, precisa ser
instalado em seu computador, por isso, eu já deixei preparado
um artigo no meu blog explicando o passo a passo para você
instalar.
Basta acessar pelo link abaixo:
https://lobodarobotica.com/blog/ide-do-arduino-o-guiadefinitivo/
16
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
17
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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ê.
18
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
19
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
20
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
21
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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");
Serial.println("Hello World");
}
void loop()
{
}
Quando esse código é executado, você deve receber um
resultado igual ao da imagem abaixo:
22
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
{
23
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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?
24
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
25
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
26
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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 (=).
27
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
28
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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);
29
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
30
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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() {
Serial.println(text); // referenciando a variável global
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”
31
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
EXEMPLO:
void setup() {
String text = "Eu so existo dentro do setup";
Serial.begin(9600); // inicia a Serial
Serial.println(text); // referenciando a variável global
text
}
void loop() {
String text = "Eu so existo dentro do loop";
Serial.println(text); // referenciando a variável global
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
32
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
33
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
34
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
35
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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()
{
}
36
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
37
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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() {
Serial.begin(9600); // inicia a Serial
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() {
}
38
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.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()
{
}
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:
39
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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() {
Serial.begin(9600); // inicia a Serial
s = s - 10; // subtrai 10 unidades a s
Serial.println(s); //imprime o valor de 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:
40
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
SINTAXE:
multiplicacao = 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()
{
}
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:
41
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
SINTAXE:
x *= 50 // surte o mesmo efeito do exemplo anterior
EXEMPLO:
int s = 250;
void setup() {
Serial.begin(9600); // inicia a Serial
s = s * 10; // multiplica 10 unidades em s
Serial.println(s); //imprime o valor de 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;
42
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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()
{
}
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() {
43
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
Serial.begin(9600); // inicia a Serial
s = s / 10; // divide 10 unidades em s
Serial.println(s); //imprime o valor de 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
x = 9 % 5; // x agora contém 4
x = 5 % 5; // x agora contém 0
44
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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() {
Serial.begin(9600); // inicia a Serial
}
void loop() {
Serial.println(i);
i++; // adiciona 1 unidade a i cada vez que o loop é
executado
delay(5000);
}
45
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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() {
Serial.begin(9600); // inicia a Serial
}
void loop() {
Serial.println(i);
i--; // subtrai 1 unidade a i cada vez que o loop é
delay(5000);
}
46
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
47
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
(>) 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ê
48
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
49
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
50
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
}
51
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
52
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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%");
}
53
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
}
void loop()
{
}
54
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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,
Clique AQUI para ter acesso ao exercício resolvido.
55
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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()
{
56
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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()
{
}
57
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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,
Clique AQUI para ter acesso ao exercício resolvido.
58
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
(!) 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()
59
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
60
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
61
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
62
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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);
delay(1000);
digitalWrite(4, LOW);
delay(1000);
}
// Liga o LED
// Aguarda 1 segundo
// Desliga o LED
// Aguarda 1 segundo
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.
63
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
64
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
/* #1 – Blink com LED */
void setup()
{
pinMode(13, OUTPUT);
}
void loop()
{
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
//
//
//
//
Liga o LED
Aguarda 1 segundo
Desliga o LED
Aguarda 1 segundo
/* Experimente mudar o tempo dentro do delay para ver a
velocidade em que o LED pisca mudar*/
65
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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);
Clique AQUI para ter acesso ao exercício resolvido.
66
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
67
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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 - 220 Ω Resistor
1 - 10K Ω Resistor
1 - Pushbutton
Jumpers
Diagrama:
68
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
/* 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);
}
}
69
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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()
Clique AQUI para ter acesso ao exercício resolvido.
70
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
}
71
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
EXEMPLO:
int
int
int
int
Led1
Led2
Led3
Led4
=
=
=
=
7;
8;
9;
10;
void setup() {
Serial.begin(9600);
pinMode(Led1, OUTPUT);
pinMode(Led2, OUTPUT);
pinMode(Led3, OUTPUT);
pinMode(Led4, OUTPUT);
}
void loop() {
if (Serial.available()) {
char Led = Serial.read();
switch (Led) {
case '1':
digitalWrite(Led1, HIGH);
digitalWrite(Led2, LOW);
digitalWrite(Led3, LOW);
digitalWrite(Led4, LOW);
break;
case '2':
digitalWrite(Led1, LOW);
digitalWrite(Led2, HIGH);
digitalWrite(Led3, LOW);
digitalWrite(Led4, LOW);
break;
case '3':
digitalWrite(Led1, LOW);
digitalWrite(Led2, LOW);
digitalWrite(Led3, HIGH);
digitalWrite(Led4, LOW);
break;
case '4':
digitalWrite(Led1, LOW);
digitalWrite(Led2, LOW);
digitalWrite(Led3, LOW);
digitalWrite(Led4, HIGH);
break;
default:
Serial.print("Valor ");
Serial.print(Led);
Serial.println(" incorreto.");
digitalWrite(Led1, LOW);
digitalWrite(Led2, LOW);
digitalWrite(Led3, LOW);
digitalWrite(Led4, LOW);
}
72
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
}
}
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.
73
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
Clique AQUI para ter acesso ao exercício resolvido.
74
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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) {
Serial.println("Hello World");
delay(2000);
}
}
void loop() {
}
75
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
76
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
77
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
Clique AQUI para ter acesso ao exercício resolvido.
78
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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() {
Serial.begin(9600); // instancia a Serial
}
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.
79
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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() {
Serial.begin(9600); // instancia a Serial
}
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.
80
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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;
• 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.
Clique AQUI para ter acesso ao exercício resolvido.
81
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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;
• 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: 50”;
• Na segunda iteração deve aparecer “O valor da contagem e:
49”;
• E assim sucessivamente até que chegue a 0;
• 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.
Clique AQUI para ter acesso ao exercício resolvido.
82
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
6 - 220 Ω Resistor
Jumpers
Diagrama:
83
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
/*
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);
}
}
84
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-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() {
Serial.begin(9600); // instancia a Serial
do {
Serial.println("Fui exibido 1 vez");
} while (x > 5); // Só será executado 1 vez pois x
é MENOR QUE 5
}
void loop() {
}
85
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
86
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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() {
Serial.begin(9600); // inicia a Serial
}
void loop() {
val = analogRead(analogPin);// Lê o pino
Serial.println(val); // imprime o valor lido na tela
}
87
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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 - 220 Ω Resistor
1 - Potenciômetro 10k Ω (Modelo Trimpot)
Jumpers
Diagrama:
88
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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);
}
89
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
90
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
91
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
92
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
}
93
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
1 - 220 Ω Resistor
Jumpers
Diagrama:
94
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
/*
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);
}
95
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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?
96
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
97
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
10 - 220 Ω Resistor
Jumpers
Diagrama:
98
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
/*
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);
}
}
}
99
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
100
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
101
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
102
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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);
}
103
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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 - 330 Ω Resistor
1 - 10K Ω Resistor
1 - Fotoresistor
Jumpers
Diagrama:
104
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
// 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)
105
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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);
}
106
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
107
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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() {
Serial.begin(9600); // inicia a Serial
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() {
108
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
return x + y; //retorna a soma de x + y
}
109
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
110
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
/*
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);
111
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
}
// Outras coisas para testar com esse projeto:
//
Ligar um LED se a temperatura exceder um valor
//
Criar um termostato
112
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
113
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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!
114
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
115
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
116
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
117
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
118
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
119
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
120
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
121
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
122
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
123
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
#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);
}
}
124
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
125
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
/*
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_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
126
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
NOTE_A4
NOTE_AS4
NOTE_B4
NOTE_C5
NOTE_CS5
NOTE_D5
NOTE_DS5
NOTE_E5
NOTE_F5
NOTE_FS5
NOTE_G5
NOTE_GS5
NOTE_A5
NOTE_AS5
NOTE_B5
NOTE_C6
NOTE_CS6
NOTE_D6
NOTE_DS6
NOTE_E6
NOTE_F6
NOTE_FS6
NOTE_G6
NOTE_GS6
NOTE_A6
NOTE_AS6
NOTE_B6
NOTE_C7
NOTE_CS7
NOTE_D7
NOTE_DS7
NOTE_E7
NOTE_F7
NOTE_FS7
NOTE_G7
NOTE_GS7
NOTE_A7
NOTE_AS7
NOTE_B7
NOTE_C8
NOTE_CS8
NOTE_D8
NOTE_DS8
440
466
494
523
554
587
622
659
698
740
784
831
880
932
988
1047
1109
1175
1245
1319
1397
1480
1568
1661
1760
1865
1976
2093
2217
2349
2489
2637
2794
2960
3136
3322
3520
3729
3951
4186
4435
4699
4978
// cria um vetor de notas
int melody[] = {
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3,
NOTE_C4
};
127
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
// 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() {
}
128
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
129
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
#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
servo1.write(180); // manda o servo ir para 180°
delay(1000); // Pausa
servo1.write(0); // manda o servo ir para 0°
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);
}
}
130
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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 - 330 Ω Resistor
1 - Diodo 1N4148
1 - NPN Transistor
Jumpers
Diagrama
131
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
/*
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--)
{
132
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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.
}
}
}
133
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
potenciômetro para ajustar o contraste do display.
um
Componentes
•
•
•
•
•
1 - Arduino Uno
1 - Protoboard
1 - Display LCD
1 - Potenciômetro
Jumpers
Diagrama
134
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
/*
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.
}
135
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
136
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
// 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ê
float
// Lê
float
// Lê
float
a umidade
h = dht.readHumidity();
temperatura como celcius
t = dht.readTemperature();
temperatura como Fahrenheit
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");
}
137
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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:
138
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
int
int
int
int
led = 13; // pino de conexão do LED
sensor = 2; // pino do sensor
state = LOW; // por padrão o sensor fica em LOW
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
}
}
}
139
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
140
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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
Serial.begin(9600); // inicia a Serial
}
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);
}
141
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
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/blog/
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.
142
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80
Infelizmente um livro uma vez baixado, não há como
adicionar novos exemplos, projetos e capítulos. Diferente do
treinamento completo, que você recebe todas as atualizações.
Esse pode ser um bom motivo para eu ver você novamente
dentro do Treinamento completo Arduhack, pois lá você
receberá todas as aulas já postadas e todas as aulas que eu ainda
vou disponibilizar.
E ainda mais, podemos estar em contato através dos
grupos exclusivos.
Você pode participar do treinamento através do link
abaixo:
https://lobodarobotica.com/treinamento-arduhackcompleto
Espero te ver lá, um grande abraço!
“Tudo parece impossível até que seja feito”
Vejo você em breve - Mateus D. Dias
Todos os direitos reservados – Lobo da Robótica 2020
143
Lobo da Robótica - ma.domingues.dias@gmail.com - CNPJ: 33.039.661/0001-80