Sumário

1. Introdução ..................................................................................................................... 4
1.1. O material .................................................................................................................. 5
2. Componentes ................................................................................................................ 6
2.1. Arduino ...................................................................................................................... 7
2.1.1. O que é Arduino? .................................................................................................. 7
2.1.2. O Arduino MEGA 2560 .......................................................................................... 7
2.2. Módulo de motor L298N ........................................................................................... 8
2.3. LCD........................................................................................................................... 10
2.4. Sensor LDR............................................................................................................... 10
2.5. LED alto brilho ......................................................................................................... 11
2.6. Servomotor.............................................................................................................. 11
2.7. Sensor IR .................................................................................................................. 12
2.8. Sensor ultrassônico ................................................................................................. 13
2.9. Motor com redução ................................................................................................ 13
3. Básico de programação........................................................................................... 15
3.1. Computador ........................................................................................................... 16
3.2. Programa de Computador ................................................................................... 16
3.3. Linguagem de Programação .............................................................................. 16
3.4. Algoritmo (Programa) ........................................................................................... 17
3.5. Variável .................................................................................................................. 17
3.6. Operador ................................................................................................................ 19
3.7. Função ................................................................................................................... 19
3.8. Comentários .......................................................................................................... 21
3.9. Estruturas de Controle ......................................................................................... 23
3.10. Bibliotecas.......................................................................................................... 31
4. Principais Funções ....................................................................................................... 33
4.1. Funções para pinos digitais ..................................................................................... 34
4.2. Funções para pinos analógicos................................................................................ 36

2
4.3. Funções para comunicação (USB) ........................................................................... 36
4.4. Funções matemáticas e de tempo .......................................................................... 37
5. Exercícios ..................................................................................................................... 39
5.1. Exercícios de compreensão ..................................................................................... 40
5.2. Seguidor de linha ..................................................................................................... 40

3
1. Introdução

4
 1.1. O material

O objetivo deste material é apresentar de forma simples e fácil o kit de

desenvolvimento do Arduino e sua programação, voltados, especialmente, para robôs
seguidores de linha.

Nosso kit é composto de:

 Arduino MEGA 2560;

 Módulo de motor;
 LCD;
 Sensor LDR
 Led Alto brilho;
 Servomotor;
 Sensor IR;
 Sensor Ultrassônico;
 Motor com redução;

Vamos começar explicando os componentes do nosso kit e depois prosseguiremos

para a montagem e programação do nosso carrinho.

5
2. Componentes

6
 2.1. Arduino

2.1.1. O que é Arduino?

O Arduino foi criado em 2005 por um grupo de 5 pesquisadores : Massimo Banzi,

David Cuartielles, Tom Igoe, Gianluca Martino e David Mellis. O objetivo era elaborar
um dispositivo que fosse ao mesmo tempo barato, funcional e fácil de programar,
sendo dessa forma acessível a estudantes e projetistas amadores. Além disso, foi
adotado o conceito de hardware livre, o que significa que qualquer um pode montar,
modificar, melhorar e personalizar o Arduino, partindo do mesmo hardware básico.

Assim, foi criada uma placa composta por um microcontrolador Atmel, circuitos de
entrada/saída e que pode ser facilmente conectada à um computador e programada
via IDE (Integrated Development Environment, ou Ambiente de Desenvolvimento
Integrado) utilizando uma linguagem baseada em C/C++, sem a necessidade de
equipamentos extras além de um cabo USB.

Depois de programado, o microcontrolador Arduino pode ser usado de forma

independente, ou seja, você pode colocá-lo para controlar um robô, uma lixeira, um
ventilador, as luzes da sua casa, a temperatura do ar condicionado, pode utilizá-lo
como um aparelho de medição ou qualquer outro projeto que vier à cabeça.

2.1.2. O Arduino MEGA 2560

O Arduino MEGA 2560 possui 54 pinos de entrada e saída digitais (dos quais 15
podem ser usados como saídas PWM) e 16 entradas analógicas. A localização de
seus pinos pode ser vista na figura 2.1.

7
 Figura 2.1

As portas digitais sem PWM podem ser usadas para ligar LED’s, por exemplo, pois só
recebem ou enviam os valores 0 (0V) para o LED desligado ou 1 (5V) para o LED
ligado, porém não podem controlar a intensidade da luz desse LED.

As entradas analógicas são usadas na leitura de sensores, pois, diferente de uma

entrada digital que fornece valores 0 ou 1 somente, entradas analógicas podem obter
diversos valores. Um valor de 0 a 1023 pode ser obtido caso um sensor esteja
medindo a intensidade da luz produzida por uma lâmpada, por exemplo. Caso um pino
digital estivesse sendo usado, só poderíamos dizer se a lâmpada estava acesa ou
apagada, com o analógico podemos dizer a intensidade dessa luz.

Como se pode ver, as portas analógicas são de entrada somente. Caso seja
necessário uma saída de um valor diferente de 0 ou 1, como, por exemplo, para
controlar a velocidade de um motor ou a intensidade da luz de uma lâmpada, ao invés
de simplesmente ligá-los ou desligá-los como o pino digital sem PWM faria, usamos
os pinos digitais com PWM, que serve para simular um sinal analógico, ele pode
enviar valores de 0 a 255.

Os pinos de alimentação ficam na barra com 6 pinos, marcada como POWER,

localizada ao lado dos pinos analógicos, como visto na figura 2.1. O primeiro pino
dessa barra, RESET, quando conectado ao GND serve para resetar o Arduino. Do
outro lado, Vin é um pino que também pode servir para alimentar o Arduino se nele for
aplicada uma tensão entre 9 e 15 volts.

2.2. Módulo de motor L298N

O Arduino não possui corrente suficiente para ativar um motor, por isso precisamos de
um módulo. A alimentação externa é ligada ao módulo que é ligado ao motor e ao
Arduino. O sinal que o Arduino envia ao módulo serve de chave para o controle do
motor. Dependendo do sinal enviado pelo Arduino, o motor executará uma função

8
diferente. A função do módulo varia de controle de velocidade a controle de sentido do
motor (anti-horário e horário). Na figura 2.2 podemos ver um exemplo de módulo de
motor com seus componentes especificados.

Figura 2.2

 (Motor A) e (Motor B) se referem aos conectores para ligação de 2 motores DC

ou 1 motor de passo;
 (Ativa MA) e (Ativa MB) – são os pinos responsáveis pelo controle PWM dos
motores A e B. Se estiver com jumper, não haverá controle de velocidade, pois
os pinos estarão ligados aos 5v. Esses pinos podem ser utilizados em conjunto
com os pinos PWM do Arduino;
 (Ativa 5v) e (5v) – Este Driver Ponte H L298N possui um regulador de tensão
integrado. Quando o driver está operando entre 6-35V, este regulador
disponibiliza uma saída regulada de +5v no pino (5v) para um uso externo (com
jumper), podendo alimentar por exemplo outro componente eletrônico. Portanto
não alimente este pino (5v) com +5v do Arduino se estiver controlando um
motor de 6-35v e jumper conectado, isto danificará a placa. O pino (5v)

9
 somente se tornará uma entrada caso esteja controlando um motor de 4-5,5v
(sem jumper), assim poderá usar a saída +5v do Arduino;

 (6-35v) e (GND) - Aqui será conectado a fonte de alimentação externa quando

o driver estiver controlando um motor que opere entre 6-35v. Por exemplo se
estiver usando um motor DC 12v, basta conectar a fonte externa de 12v neste
pino e (GND);
 (Entrada) - Este barramento é composto por IN1, IN2, IN3 e IN4. Sendo estes
pinos responsáveis pela rotação do Motor A (IN1 e IN2) e Motor B (IN3 e IN4);

2.3. LCD

O LCD serve para que a calibração dos sensores possa ser visualizada e ajustada
sem que haja necessidade do robô estar conectado a um computador. Na figura 2.3
podemos ver um exemplo de LCD.

Figura 2.3

2.4. Sensor LDR

O sensor LDR (do inglês Light Dependent Resistor), em português Resistor
Dependente de Luz, como o próprio nome já diz, é um sensor que mede a intensidade

10
de luz que incide sobre ele. Quanto maior a intensidade da luz que ele recebe, menor
a sua resistência. No nosso projeto do seguidor de linha será utilizado para a
identificação da cor prata. Na figura 2.4 é apresentado um exemplo de sensor LDR.

Figura 2.4

2.5. LED alto brilho

O LED alto brilho será utilizado para auxiliar o funcionamento do LDR, evitando que
mudanças na iluminação possam dificultar a identificação da cor prata. O LED ilumina
o objeto logo a frente do sensor, possibilitando uma iluminação sempre homogênea.
Na figura 2.5 vemos um exemplo de LED alto brilho.

Figura 2.5

Os LED’s possuem um achatamento em um dos seus lados (lado direito na figura 2.4),
isso serve para indicar qual lado é o positivo e qual é o negativo. O lado achatado é o
negativo, esse lado deve ser ligado no GND. O outro lado é o positivo e deve ser
ligado no pino digital, porém a tensão fornecida pelo pino digital é de 5V e isso é mais
do que o LED pode suportar, portanto entre o pino digital e o lado positivo do LED
deve-se ligar um resistor.

2.6. Servomotor

11
Um servomotor tem funcionamento semelhante ao de um motor. Porém em vez de
girar ou se mover livremente sem um controle mais efetivo de posição como a maioria
dos motores, ele é movido para que atinja uma posição específica. Um sinal é enviado
ao servomotor indicando a posição final desejada, ele então determina a posição
inicial em que ele se encontra e realiza o movimento necessário para que a posição
final seja atingida. O servomotor não gira mais do que 180° como fazem a maioria dos
motores.

Por possibilitar o controle de posição, o servomotor será utilizado para controle da

garra que apanhará objetos no nosso seguidor de linha. Na figura 2.6 é possível ver
um exemplo de servomotor.

Figura 2.6

2.7. Sensor IR

Sensor IR ou sensor infravermelho é composto por um par emissor e receptor, como

pode ser visto na figura 2.7. Uma luz infravermelha é emitida e seu reflexo é recebido,
através da análise desse reflexo podemos determinar a intensidade da cor do objeto
sobre o qual a luz incidiu. Cores escuras absorvem mais luz e refletem menos e cores
claras absorvem menos luz e refletem mais, com isso podemos analisar a intensidade
da luz refletida e dizer, por exemplo, se o objeto é branco ou preto, possibilitando a
identificação de linhas escuras no chão branco.

Mesmo a luz infravermelha sendo invisível a olho nu, ela é uma luz e também é
absorvida e refletida. Para testarmos se o emissor está realmente emitindo a radiação
infravermelha podemos filmar o sensor em funcionamento com uma câmera de
celular, por exemplo, na câmera será possível visualizar a luz emitida.

12
 Figura 2.7

2.8. Sensor ultrassônico

O sensor ultrassônico pode ser chamado de “olhos do robô”, pois sua função é de
“enxergar” objetos e também pela sua semelhança a um par de olhos, como pode ser
visto na figura 2.8. Ele é utilizado para detectar objetos e também determinar a que
distância eles se encontram. Tem funcionamento semelhante ao do sensor IR. Uma
onda sonora é emitida pelo sensor e seu reflexo é recebido e analisado, de acordo
com o tempo que essa onda levou para chegar até o objeto e retornar ao sensor é
possível calcular a distância a que esse objeto se encontra do sensor. Sabendo a
distância é possível programar os motores para desviarem do objeto.

Figura 2.8

2.9. Motor com redução

É o motor que controla os movimentos do seguidor de linha. Cada motor controla uma
roda, no caso do seguidor de linha não são necessárias mais que duas rodas. Na
figura 2.9 estão representados um motor e sua roda. Com a programação de cada
motor é possível controlar a velocidade, a direção e o sentido do robô.

13
Figura 2.9

14
3. Básico de programação

15
 3.1. Computador
O Arduino pode ser considerado um tipo de computador. Um computador é, de forma
simplificada, uma máquina que processa instruções. Essas instruções são
processadas no "cérebro" do computador, que se chama microprocessador. Todo
computador possui pelo menos um microprocessador. O Arduino, por exemplo, nada
mais é do que um computador muito pequeno, e ele utiliza um microprocessador do
modelo ATmega. Alguns microprocessadores, como o ATmega, também são
chamados de microcontroladores.

3.2. Programa de Computador

Um programa de computador, ou software, é uma sequência de instruções que são
enviadas para o computador. Cada tipo de microprocessador (cérebro) entende
um conjunto de instruções diferente, ou seja, o seu próprio "idioma". Também
chamamos esse idioma de linguagem de máquina.

As linguagens de máquina são, no fundo, as únicas linguagens que os computadores

conseguem entender, só que elas são muito difíceis para os seres humanos
entenderem. É por isso que nós usamos uma coisa chamada linguagem de
programação.

No caso de sistemas como o Arduino (os chamados sistemas embarcados), o software

que roda no microprocessador é também chamado de firmware.

3.3. Linguagem de Programação

Nós seres humanos precisamos converter as nossas ideias para uma forma que os
computadores consigam processar, ou seja, a linguagem de máquina. Os
computadores de hoje (ainda) não conseguem entender a linguagem natural que nós
usamos no dia a dia, então precisamos de um outro "idioma" especial para instruir o
computador a fazer as tarefas que desejamos. Esse "idioma" é uma linguagem de
programação, e na verdade existem muitas delas.

Essas linguagens de programação também são chamadas de linguagens de

programação de alto nível. A linguagem de programação utilizada no Arduino é a
linguagem C++ (com pequenas modificações), que é uma linguagem muito tradicional
e conhecida.

Para converter um programa escrito em uma linguagem de alto nível para linguagem
de máquina, nós utilizamos uma coisa chamada compilador. A ação de converter um
programa para linguagem de máquina é chamada compilar. Para compilar um
programa, normalmente se utiliza um ambiente de desenvolvimento (ou IDE, do
inglês Integrated Development Environment), que é um aplicativo de computador que
possui um compilador integrado, onde você pode escrever o seu programa e compilá-
lo. No caso do Arduino, esse ambiente de desenvolvimento é o Arduino IDE.

O texto contendo o programa em uma linguagem de programação de alto nível

também é conhecido como o código fonte do programa.

16
 3.4. Algoritmo (Programa)
Um algoritmo, ou simplesmente programa, é uma forma de dizer para um computador
o que ele deve fazer, de uma forma que nós humanos conseguimos entender
facilmente. Os algoritmos normalmente são escritos em linguagens de programação
de alto nível. Isso se aplica a praticamente qualquer computador, inclusive o Arduino,
onde um algoritmo também é conhecido como sketch. Para simplificar, a partir de
agora nós vamos nos referir aos algoritmos, programas ou sketches simplesmente
como "programas".

Um programa é composto de uma sequência de comandos, normalmente escritos em

um arquivo de texto. Neste material, vamos usar como base os comandos do
programa mais simples do Arduino, o Blink, que simplesmente acende e apaga um
LED, e vamos destrinchá-lo ao longo do capítulo. Veja abaixo o código fonte do Blink:

int led = 13;

void setup() {

pinMode(led, OUTPUT);

void loop() {

digitalWrite(led, HIGH);

delay(1000);

digitalWrite(led, LOW);

delay(1000);

3.5. Variável
Uma variável é um recurso utilizado para armazenar dados em um programa de
computador. Todo computador possui algum tipo de memória, e uma variável
representa uma região da memória usada para armazenar uma determinada
informação. Essa informação pode ser, por exemplo, um número, um caractere ou
uma sequência de texto. Para podermos usar uma variável em um programa Arduino,
nós precisamos fazer uma declaração de variável, como por exemplo:

17
int led;

Nesse caso estamos declarando uma variável do tipo int chamada led . Em seguida
nós falaremos mais sobre o tipo de dado de uma variável.

3.5.1. Tipo de Dado

O tipo de dado de uma variável significa, como o próprio nome diz, o tipo de
informação que se pode armazenar naquela variável. Em muitas linguagens de
programação, como C++, é obrigatório definir o tipo de dado no momento da
declaração da variável, como vimos na declaração da variável led acima. No caso
dos módulos Arduino que usam processador ATmega, os tipos mais comuns de dados
que utilizamos são:

 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)

3.5.2. Atribuição
Atribuir um valor a uma variável significa armazenar o valor nela para usar
posteriormente. O comando de atribuição em C++ é o = . Para atribuirmos o
valor 13 à variável led que criamos acima, fazemos assim:

led = 13;

Quando se armazena um valor em uma variável logo na sua inicialização, chamamos

isso de inicialização de variável. Assim, no nosso programa de exemplo temos:

int led = 13;

O objetivo dessa linha de código é dizer que o pino 13 do Arduino será utilizado para
acender o LED, e armazenar essa informação para usar depois ao longo do programa.

Os valores fixos usados no programa, como o valor 13 acima, são chamados

de constantes, pois, diferentemente das variáveis, o seu valor não muda.

18
 3.6. Operador
Um operador é um conjunto de um ou mais caracteres que serve para operar sobre
uma ou mais variáveis ou constantes. Um exemplo muito simples de operador é o
operador de adição, o + . Digamos que queremos somar dois números e atribuir a
uma variável x . Para isso, fazemos o seguinte:

x = 2 + 3;

Após executar o comando acima, a variável x irá conter o valor 5 .

Cada linguagem de programação possui um conjunto de operadores diferente. Alguns

dos operadores mais comuns na linguagem C++ são:

 Operadores aritméticos:
o + : adição ("mais")
o - : subtração ("menos")
o * : multiplicação ("vezes")
o / : divisão ("dividido por")
 Operadores lógicos:
o && : conjunção ("e")
o || : disjunção ("ou")
o == : igualdade ("igual a")
o != : desigualdade ("diferente de")
o ! : negação ("não")
o > : "maior que"
o < : "menor que"
o >= : "maior ou igual a"
o <= : "menor ou igual a"
 Operadores de atribuição:
o = : atribui um valor a uma variável, como vimos acima.

Ao longo do desenvolvimento dos seus projetos, aos poucos você se familiarizará com
todos esses operadores.

3.7. Função
Uma função é, em linhas gerais, uma sequência de comandos que pode ser reutilizada
várias vezes ao longo de um programa. Para criar uma função e dizer o que ela faz,
nós precisamos fazer uma declaração de função. Veja como uma função é declarada
no nosso programa de exemplo:

void setup() {

19
 pinMode(led, OUTPUT);

Aqui estamos declarando uma função com o nome setup() . O que ela faz é executar
os comandos de uma outra função pinMode() . A ação de executar os comandos de
função previamente declarada é denominada chamada de função. Nós não
precisamos declarar a função pinMode() porque ela já é declarada automaticamente
no caso do Arduino.

3.7.1. Chamada de Função

Chamar uma função significa executar os comandos que foram definidos na sua
declaração. Uma vez declarada, uma função pode ser chamada várias vezes no
mesmo programa para que seus comandos sejam executados novamente. Para
chamarmos a nossa função setup() , por exemplo, nós usaríamos o seguinte
comando:

setup();

No entanto, no caso do Arduino, nós não precisamos chamar a função setup() ,

porque ela é chamada automaticamente. Quando compilamos um programa no
Arduino IDE, ele chama a função setup() uma vez e depois chama a
função loop() repetidamente até que o Arduino seja desligado ou reiniciado.

3.7.2. Valor de Retorno

A palavra chave que vem antes do nome da função na declaração define o tipo
do valor de retorno da função. Toda vez que uma função é chamada, ela é executada
e devolve ou retorna um determinado valor - esse é o valor de retorno, ou
simplesmente retorno da função. O valor de retorno precisa ter um tipo, que pode ser
qualquer um dos tipos de dados citados anteriormente. No caso da nossa
função setup() , o tipo de retorno é void , o que significa que a função não retorna
nada.

Para exemplificar, vamos criar uma função que retorna alguma coisa, por exemplo, um
número inteiro. Para retornar um valor, nós utilizamos o comando return :

int f() {

return 1;

Quando chamada, a função f() acima retorna sempre o valor 1 . Você pode usar o
valor de retorno de uma função para atribuí-lo a uma variável. Por exemplo:

20
x = f();

Após declarar a função f() e chamar o comando de atribuição acima, a variável x irá
conter o valor 1 .

3.7.3. Parâmetros

Um outro recurso importante de uma função são os parâmetros. Eles servem para
enviar algum dado para a função quando ela é chamada. Vamos criar por exemplo
uma função que soma dois números:

int soma(int a, int b) {

return a + b;

Aqui acabamos definir uma função chamada soma() , que aceita dois números inteiros
como parâmetros. Nós precisamos dar um nome para esses parâmetros, e nesse caso
escolhemos a e b . Esses parâmetros funcionam como variável que você pode usar
dentro da função. Sempre que chamarmos a função soma() , precisamos fornecer
esses dois números. O comando return a + b; simplesmente retorna a função com a
soma dos dois números. Vamos então somar 2 + 3 e atribuir o resultado para uma
variável x :

x = soma(2, 3);

Após a chamada acima, a variável x irá conter o valor 5 .

3.8. Comentários
Um comentário é um trecho de texto no seu programa que serve apenas para explicar
(documentar) o código, sem executar nenhum tipo de comando no programa. Muitas
vezes, os comentários são usados também para desabilitar comandos no código.
Nesse caso, dizemos que o código foi comentado.

Na linguagem C++, um comentário pode ser escrito de duas formas:

 Comentário de linha: inicia-se com os caracteres // , tornando todo o resto da linha

atual um comentário.
 Comentário de bloco: inicia-se com os caracteres /* e termina com os
caracteres */ . Todo o texto entre o início e o término se torna um comentário,
podendo ser composto de várias linhas.

Para facilitar a visualização, os ambientes de desenvolvimento geralmente mostram os

comentários em uma cor diferente. No caso do Arduino IDE, por exemplo, os

21
comentários são exibidos na cor cinza. Vamos então explicar o que o programa de
exemplo faz, inserindo nele vários comentários explicativos:

/*

Programação para Arduino - Primeiros Passos

Programa de exemplo: Blink

*/

/*

Declaração da variável "led"

Indica que o LED está conectado no pino digital 13 do Arduino (D13).

*/

int led = 13;

/*

Declaração da função setup()

Esta função é chamada apenas uma vez, quando o Arduino é ligado ou rei
niciado.

*/

void setup() {

// Chama a função pinMode() que configura um pino como entrada ou sa

ída

pinMode(led, OUTPUT); // Configura o pino do LED como saída

/*

22
Declaração da função loop()

Após a função setup() ser chamada, a função loop() é chamada repetidam

ente até

o Arduino ser desligado.

*/

void loop() {

// Todas as linhas a seguir são chamadas de função com passagem de p

arâmetros

// As funções são executadas em sequência para fazer o LED acender e

apagar

digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED

, acendendo-o

delay(1000); // Espera 1000 milissegundos (um segundo)

digitalWrite(led, LOW); // Atribui nível lógico baixo ao pino do LE

D, apagando-o

delay(1000); // Espera 1000 milissegundos (um segundo)

// Após terminar a função loop(), ela é executada novamente repetida

s vezes,

// e assim o LED continua piscando.

3.9. Estruturas de Controle

Estruturas de controle são blocos de instruções que alteram o fluxo de execução do
código de um programa. Com elas é possível fazer coisas como executar comandos
diferentes de acordo com uma condição ou repetir uma série de comandos várias
vezes, por exemplo.

A seguir nós veremos algumas das estruturas de controle mais comuns usadas nas
linguagens de programação em geral. Vamos também modificar o nosso programa de
teste para exemplificar melhor como essas estruturas funcionam.

23
 3.9.1. While

O while é uma estrutura que executa um conjunto de comandos repetidas vezes

enquanto uma determinada condição for verdadeira. While em inglês quer dizer
"enquanto", e pronuncia-se "uái-ou". Ele segue o seguinte formato:

while(condição) {

...

Vamos então fazer uma modificação no nosso programa para exemplificar melhor
como o while funciona. O nosso objetivo agora é fazer o LED piscar três vezes,
depois esperar cinco segundos, piscar mais três vezes e assim por diante. Nós vamos
mudar o conteúdo da função loop() para o seguinte:

// Variável para contar o número de vezes que o LED piscou

int i = 0;

// Pisca o LED três vezes

while(i < 3) {

digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do L

ED, acendendo-o

delay(1000); // Espera 1000 milissegundos (um segundo)

digitalWrite(led, LOW); // Atribui nível lógico baixo ao pino do

LED, apagando-o

delay(1000); // Espera 1000 milissegundos (um segundo)

i = i + 1; // Aumenta o número de vezes que o LED pi

scou

delay(5000); // Espera 5 segundos para piscar o LED de

novo

24
Primeiro nós declaramos uma variável i . Essa variável vai contar quantas vezes o
LED já piscou desde o início do programa ou desde a última pausa de cinco segundos.
Nós vamos inicializar essa variável com zero porque no início da função loop() o LED
ainda não piscou nenhuma vez sob essas condições.

Em seguida nós inserimos o comando while , que deve ser seguido de

uma condição definida entre parênteses. Enquanto essa condição for verdadeira, todo
o bloco de comandos entre os caracteres { e } é executado repetidamente. No caso
do nosso programa, enquanto o número de "piscadas" do LED (representado pela
variável i ) for menor do que três, nós continuamos a executar os comandos que
fazem o LED piscar. Isso é representado pela expressão i < 3 dentro dos parênteses.

Entre os caracteres { e } nós colocamos o código que faz o LED piscar, como
anteriormente, mas não podemos nos esquecer de somar 1 à variável que conta o
número de "piscadas". Isso é feito na seguinte linha de código:

i = i + 1; // Aumenta o número de vezes que o LED pi

scou

Veja que após executar todos os comandos entre { e } , sempre teremos na

variável i o número de vezes que o LED piscou desde o início da função loop() .
Vamos percorrer a sequência de passos executada cada vez que a função loop() é
chamada:

1. Atribuímos 0 à variável i : o LED ainda não piscou nenhuma vez.

2. Comparamos se i < 3 : como 0 é menor do que 3 , executamos os comandos
entre { e } :
1. Executamos os comandos para acender e apagar o LED.
2. Somamos 1 à variável i , tornando-a 1 : sabemos que o LED piscou uma vez.
3. Voltamos ao início do while e comparamos se i < 3 : como 1 é menor do que 3 ,
executamos os comandos entre { e } novamente:
1. Executamos os comandos para acender e apagar o LED.
2. Somamos 1 à variável i , tornando-a 2 : sabemos que o LED piscou duas
vezes.
4. Voltamos ao início do while e comparamos se i < 3 : como 2 é menor do que 3 ,
executamos os comandos entre { e } novamente:
1. Executamos os comandos para acender e apagar o LED.
2. Somamos 1 à variável i , tornando-a 3 : sabemos que o LED piscou três
vezes.
5. Voltamos ao início do while e comparamos se i < 3 : como 3 não é menor do
que 3 , não executamos mais os comandos entre { e } e prosseguimos à
próxima instrução.

25
6. Esperamos cinco segundos por meio da chamada delay(5000) .

Após esses passos, chegamos ao final da função loop() , e como já sabemos, ela é
chamada novamente pelo sistema do Arduino. Isso reinicia o ciclo, executando os
passos acima indefinidamente.

Rode o programa modificado com as instruções acima no seu Arduino e tente variar o
número de "piscadas" e o número

3.9.2. For

Agora que nós já aprendemos o comando while, fica muito fácil aprender o
comando for, pois ele é quase a mesma coisa. Vamos modificar o conteúdo da
função loop() como fizemos acima, porém usando o for no lugar do while :

// Variável para contar o número de vezes que o LED piscou

int i;

// Pisca o LED três vezes

for(i = 0; i < 3; i++) {

digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do L

ED, acendendo-o

delay(1000); // Espera 1000 milissegundos (um segundo)

digitalWrite(led, LOW); // Atribui nível lógico baixo ao pino do

LED, apagando-o

delay(1000); // Espera 1000 milissegundos (um segundo)

delay(5000); // Espera 5 segundos para piscar o LED de

novo

A primeira modificação que fizemos foi declarar a variável i sem inicializá-la com o
valor 0 . Nós podemos fazer isso porque o comando for fará isso para a gente. Ele
segue o seguinte formato:

for(inicialização; condição; finalização) {

26
 ...

Vamos descrever cada item separadamente:

 Condição: é uma expressão verificada repetidamente, de forma idêntica à

condição entre parênteses do while . Enquanto ela for verdadeira, os comandos
entre { e } continuam sendo executados.
 Inicialização: é um comando executado apenas uma vez no início do
comando for .
 Finalização: é um comando executado repetidas vezes ao final de cada execução
dos comandos entre { e } .

Podemos então verificar que o for nada mais é do que um while acrescido de um
comando de inicialização e um comando de finalização. Para o nosso programa de
teste, esses comandos são, respectivamente:

 i = 0 : inicializa a contagem do número de "piscadas".

 i++ : soma 1 à variável i ao final da execução dos comandos entre { e } ; nesse
caso ele é equivalente ao comando i = i + 1 . O operador ++ é chamado de
operador de incremento, e é muito usado na linguagem C++.

Se executarmos o programa acima no Arduino, veremos que o resultado é o mesmo

que obtivemos com o programa que fizemos anteriormente utilizando o while .

3.9.3. If

O if é uma das estruturas mais básicas de programação em geral. If significa "se" em

inglês, e é exatamente isso que ele faz: ele verifica uma expressão e, apenas se ela
for verdadeira, executa um conjunto de comandos. Em linguagem natural, ele executa
uma lógica do tipo: "se isso for verdadeiro, então faça aquilo"

Para ilustrar, vamos modificar o nosso programa de exemplo para que ele faça a
mesma coisa que fizemos com o while e o for acima, porém vamos fazer isso usando
um if , que segue o seguinte formato:

if(condição) {

...

27
A lógica é muito simples: sempre que a condição for verdadeira, os comandos
entre { e } são executados, caso contrário o programa prossegue sem executá-los.
Vamos ver então como fica a função loop() :

// Variável para contar o número de vezes que o LED piscou

int i = 0;

void loop() {

digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do LED

, acendendo-o

delay(1000); // Espera 1000 milissegundos (um segundo)

digitalWrite(led, LOW); // Atribui nível lógico baixo ao pino do LE

D, apagando-o

delay(1000); // Espera 1000 milissegundos (um segundo)

i++; // Incrementa o número de "piscadas"

if(i == 3) {

delay(5000); // Espera 5 segundos para piscar o LED de n

ovo

i = 0; // Reinicia o contador de número de "piscad

as"

Aqui a lógica é um pouco diferente: nós vamos manter a função loop() piscando o
LED como no programa original, porém vamos inserir uma espera adicional de 5
segundos após cada 3 piscadas. Para isso, criamos uma variável i fora da
função loop() ; ela precisa ser declarada de fora da função para poder reter o seu
valor entre cada execução da função loop() . Chamamos isso de variável global.
Quando a variável é declarada dentro do corpo da função, ela não retém o valor entre

28
cada execução, sendo reiniciada a cada vez que a função é reexecutada. Chamamos
isso de variável local.

Nós usaremos então essa variável global i para contar, novamente, o número de
vezes que o LED acendeu e apagou. Na declaração da variável, nós a inicializamos
com o valor 0 para indicar que o LED não acendeu nenhuma vez ainda. A
função loop() então começa a ser executada, acendendo e apagando o LED. Para
contar o número de vezes que o LED piscou, nós adicionamos a seguinte linha de
código:

i++; // Incrementa o número de "piscadas"

Em seguida utilizamos o if para verificar se acabamos de acender o LED pela terceira

vez. Para isso, usamos a expressão i == 3 na condição do ìf . Se essa expressão for
verdadeira, isso que dizer que o LED já acendeu 3 vezes, então inserimos uma pausa
adicional de 5 segundos com a chamada delay(5000) e reiniciamos a contagem do
número de "piscadas" novamente com o seguinte comando:

i = 0; // Reinicia o contador de número de "piscad

as"

A partir daí a função loop() continua sendo chamada e o ciclo se inicia novamente.

3.9.4. If-Else

O if-else, também conhecido como if-then-else, pode ser visto como uma extensão do
comando if . Else em inglês significa "caso contrário", e ele faz exatamente o que o
nome diz: "se isso for verdadeiro, então faça aquilo, caso contrário, faça outra coisa".
Ele segue o seguinte formato:

if(condição) {

...

} else {

...

Para exemplificar, vamos usar o programa do for que mostramos acima, mas vamos
dessa vez fazer o LED acender e apagar quatro vezes antes de dar uma pausa de
cinco segundos. Depois vamos fazer com que na terceira de cada uma dessas quatro
"piscadas", o LED acenda por um período mais curto. Dentro da função loop() ,
teremos o seguinte:

29
 // Variável para contar o número de vezes que o LED piscou

int i;

// Pisca o LED três vezes

for(i = 0; i < 3; i++) {

if(i == 2) {

digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do

LED, acendendo-o

delay(200); // Espera 200 milissegundos (um segundo

)

digitalWrite(led, LOW); // Atribui nível lógico baixo ao pino d

o LED, apagando-o

delay(1800); // Espera 1800 milissegundos (um segund

o)

} else {

digitalWrite(led, HIGH); // Atribui nível lógico alto ao pino do

LED, acendendo-o

delay(1000); // Espera 1000 milissegundos (um segund

o)

digitalWrite(led, LOW); // Atribui nível lógico baixo ao pino d

o LED, apagando-o

delay(1000); // Espera 1000 milissegundos (um segund

o)

delay(5000); // Espera 5 segundos para piscar o LED de

novo

30
Aqui o que fazemos é, toda vez que vamos acender o LED, verificar se é a terceira vez
que isso acontece, por meio do comando if com a condição i == 2 . Se essa
expressão for verdadeira, isso quer dizer que já acendemos o LED duas vezes e
estamos prestes a acendê-lo pela terceira vez; nesse caso mudamos o tempo que o
LED fica aceso para um valor menor, de 0,2 segundo (uma redução de 0,8 segundo) e
o tempo que ele fica apagado para um valor maior, de 1,8 segundos (aumento de 0,8
segundo).

Mas e se essa não for a terceira vez que o LED está sendo acionado? É aí que entra
o else : se a condição do if for verdadeira, o bloco de comandos entre { e } logo
após o if é executado, caso contrário, o bloco entre { e } após o else é executado.
Isso quer dizer que para a primeira, segunda e quarta "piscadas" será usado o tempo
padrão de um segundo.

3.10. Bibliotecas
As coisas que aprendemos nas seções anteriores são importantes para implementar a
lógica do seu programa no Arduino, mas normalmente você vai querer fazer mais
coisas além de apenas acender um LED. Quando se faz tarefas mais complexas ou se
utiliza algum outro circuito conectado ao seu Arduino, um recurso muito importante são
as bibliotecas.

Uma biblioteca é basicamente composta de código fonte adicional que você adiciona
ao seu projeto por meio do comando include. Vejamos como adicionar, por exemplo,
uma biblioteca para controle de um display de cristal liquido (LCD):

#include <LiquidCrystal.h>

Uma biblioteca do Arduino se apresenta normalmente como uma ou mais classes que
possuem funções, os métodos, para acionar dispositivos, configurá-los ou executar
alguma outra tarefa. Continuando com o exemplo do display de cristal líquido, para
usá-lo no seu programa, primeiro é preciso inicializá-lo. O que fazemos nesse caso é
criar um objeto para acessar o LCD (tecnicamente isso se chama instanciar um
objeto). Vejamos como isso é feito:

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

Quando fazemos isso, lcd se torna um objeto da classe LiquidCrystal . Isso é o

equivalente a criar uma variável do tipo LiquidCrystal . Os parâmetros que são
passados entre parênteses servem para inicializar a configuração desse objeto, e
nesse caso correspondem aos números dos pinos que foram utilizados para conectar
o LCD ao Arduino.

Quase sempre as bibliotecas de Arduino possuem um método begin() , que serve

para fazer a configuração inicial do dispositivo que está sendo controlado. Para
chamar a função begin() do objeto lcd que criamos, fazemos o seguinte:

31
 lcd.begin(16, 2);

Normalmente esse método begin() é chamado de dentro da função setup() , ou seja,

durante a inicialização do programa. Os parâmetros do método begin() , nesse caso,
correspondem ao número de colunas e o número de linhas do LCD, respectivamente.

Feitos esses passos, já podemos escrever texto no LCD. Fazemos isso usando o
método print() do objeto lcd , sempre que precisarmos ao longo do programa:

lcd.print("Oi!");

O método print() é apenas um dos vários métodos disponíveis na

biblioteca LiquidCrystal . Para saber todos os métodos fornecidos por uma
determinada biblioteca, é preciso consultar a documentação fornecida com ela.

Este é o processo básico de utilização de bibliotecas no Arduino. Para mais

informações, leia a documentação fornecida com a biblioteca que você está usando.

32
4. Principais Funções

33
 4.1. Funções para pinos digitais

Função Exemplo Notas

pinMode(pino,modo) Serve para pinMode(2,OUTPUT); Essa função é

estabelecer a direção do fluxo de Aqui o pino 2 é sempre escrita
informações em qualquer dos 14 selecionado para dentro da função
pinos digitais. Dois parâmetros transmitir informações do setup( ).
devem ser passados à função: o Arduino para um circuito
primeiro indica qual pino vai ser externo qualquer. Para
usado; o segundo, se esse pino vai configurar esse pino
ser entrada ou se vai ser saída como entrada, o segundo
dessas informações. parâmetro dessa função
deve ser INPUT.

digitalRead(pino) Uma vez int chave =

configurado um certo pino como digitalRead(3); Nesse
entrada com a função pinMode( ), a exemplo a variável inteira
informação presente nesse pino ‘chave’ vai guardar o
pode ser lida com a função estado lógico
digitalRead( ) e armazenada numa (verdadeiro/falso)
variável qualquer. presente no pino digital
3.

digitalWrite(pino,valor) Para enviar digitalWrite(2,HIGH); É necessário

um nível lógico para qualquer pino Aqui uma tensão de 5 configurar
digital do Arduino utiliza-se essa volts é colocada no pino previamente o pino
função. Dois parâmetros são 2. Para enviar terra para como saída com a
requeridos: o número do pino e o esse pino o segundo função pinMode( ).
estado lógico (HIGH/LOW ) em que parâmetro deverá ser
esse pino deve permanecer. LOW.

analogWrite(pino,valor) O Arduino analogWrite(10,128); Modulação por

pode gerar tensões analógicas em 6 Com esses parâmetros Largura de Pulsos,
de seus 14 pinos digitais com a uma tensão analógica de ou PWM (Pulse
função analogWrite( ). Dois 2,5 volts vai aparecer no Width Modulation)
parâmetros devem ser passados à pino 10. Não é na lingua inglesa, é
função: o primeiro indica em qual necessário configurar um uma técnica usada
pino será gerada a tensão; o pino PWM como saída para gerar tensões
segundo determina a amplitude com a função pinMode( ) analógicas a partir
dessa tensão, e deve ter valores quando se chama função de uma sequência
entre 0 (para 0 volt) e 255 (para 5 analogWrite( ). de pulsos digitais.
volts).

34
 Função Exemplo Notas

attachInterrupt(pino,função,modo) attachInterrupt(0,conta LOW - dispara a

Essa função é uma rotina de serviço dor,RISING); Nesse interrupção quando
de interrupção, ou ISR (Interrupt exemplo a função o pino está em 0;
Service Routine) em inglês. Toda ‘contador’ vai ser CHANGE - dispara
vez que ocorrer uma interrupção por chamada quando o sempre que o pino
hardware no pino digital 2 ou no 3 Arduino detetar uma muda de estado
do Arduino uma outra função, criada mudança do nível LOW (de 0 para 1, ou
pelo programador, vai ser chamada. para o nível HIGH em vice-versa);
O terceiro parâmetro, modo, informa seu pino 2. Nessa ISR o RISING - somente
como a interrupção vai ser parâmetro 0 monitora o quando o pino
disparada, se na borda de subida do pino 2, o parâmetro 1 muda de 0 para 1;
pulso detetado no pino do Arduino, monitora o pino 3. FALLING -
se na borda de descida, se quando somente quando o
o pulso for baixo ou se na mudança pino muda de 1
de nível desse pulso. para 0.

pulseIn(pino,valor,espera) Essa pulseIn(4,HIGH); Aqui Uma aplicação

função mede a largura em essa função vai interessante para
microssegundos de um pulso em monitorar o pino 4, e essas duas últimas
qualquer pino digital. O parâmetro quando o nível nesse funções pode ser
‘valor’ diz à função que tipo de pulso pino mudar de LOW para vista no meu livro
deve ser medido, se HIGH ou LOW. HIGH a sua largura vai “Experimentos com
O parâmetro ‘espera’ (time out) é ser medida até que seu o Arduino”, no
opcional e se passado à função faz nível volte para LOW. capítulo que mostra
com que a medida do pulso só Se, por exemplo, for como montar um
comece após o tempo em passado o valor 100 contador de dois
microssegundos ali especificado. como terceiro parâmetro, dígitos com
a medida da largura do mostradores de 7-
pulso só será disparada segmentos.
após 100 uS.

35
 4.2. Funções para pinos analógicos

Funçao Exemplo Notas

analogRead(pino) Essa int sensor = Os pinos analógicos são

função lê o nível analógico analogRead(A0); Aqui a reconhecidos pela
presente no pino indicado variável inteira ‘sensor’ vai linguagem C do Arduino
pelo parâmetro entre armazenar a tensão analógica tanto como A0 a A5
parênteses e, após a convertida para digital como 14 a 19. Assim, a
conversão o guarda em uma presente no pino A0. Essa mesma expressão acima
variável determinada pelo informação vai ser um valor pode ser escrita tambem
programador. inteiro entre 0 (para 0 volt no da seguinte forma: int
pino) e 1023 (se 5 volts no sensor =
pino). Uma tensão de 2,5 analogRead(14);
volts no pino A0 vai fazer a
variável ‘sensor’ guardar o
valor inteiro 512.

4.3. Funções para comunicação (USB)

Função Exemplo Notas

Serial.begin(taxa) Essa Serial.begin(9600); Nesse Essa função vai sempre

função habilita a porta exemplo essa função fixa dentro da função setup( ).
serial e fixa a taxa de a taxa de comunicação em
transmissão e recepção em 9600 bps. Os pinos digitais
bits por segundo entre o 0 e 1 não podem ser
computador e o Arduino. utilizados como entrada ou
como saída de dados
quando a porta serial é
habilitada por essa função.

Serial.println(valor,formato) Como a anterior essa função envia para a porta serial

um caracter ASCII com os mesmos parâmetros opcionais de ‘formato’, porem
acrescenta ao final da transmissão o caracter Carriage Return (retorno ao início da
linha) e o caracter New Line (mudança para a próxima linha).

36
 4.4. Funções matemáticas e de tempo

Função Exemplo Notas

delay(ms) Essa função delay(1000); Com esse Durante o período em

pausa o programa por um parâmetro o programa vai que essa função está
período em milissegundos pausar durante 1 segundo ativa qualquer outra
indicado pelo parâmetro (1000 ms). função no programa
entre parênteses. é suspensa; é
equivalente ao HALT
em Assembly.
Somente as
interrupções de
hardware podem
parar essa função.

delayMicroseconds(us) delayMicroseconds(1000); As mesmas

Essa função pausa o Com esse parâmetro o observações acima
programa por um período programa vai pausar durante 1 para a função
em microssegundos ms (1000 us). delay(ms) são
indicado pelo parâmetro válidas aqui.
entre parênteses.

millis( ) Retorna o número long total = millis( ); Aqui a Essa variável vai ser
de milissegundos desde variável inteira longa (de 32 resetada depois de
que o Arduino começou a bits) ‘total’ vai guardar o tempo aproximadamente 9
executar o programa em ms desde que o Arduino foi horas.
corrente. inicializado.

random(min,max) Gera int valor = random(100,400); À O parâmetro min é

números pseudo-aleatórios variável ‘valor’ vai ser atribuido opcional e se
entre os limites min e max um número inteiro qualquer excluído o limite
especificados como entre 100 e 400. mínimo é 0. No
parâmetros. exemplo variável
‘valor’ poderá ser
qualquer número
inteiro entre 0 e 400.

abs(x) Retorna o módulo ou float valor = abs(-3.14); À

valor absoluto do número variável ‘valor’ vai ser atribuído
real passado como o número em ponto flutuante (e
parâmetro. sem sinal) 3.14.

37
 Funçao Exemplo Notas

map(valor,min1,max1,min int valor = map(analog Com essa função é

2,max2) A função map( ) Read(A0),0,1023,0,255)); A possível reverter uma
converte uma faixa de variável ‘valor’ vai guardar a faixa de valores,
valores para outra faixa. O leitura do nível analógico no exemplo: int valor =
primeiro parâ- metro ‘valor’ pino A0 convertida da faixa de map(x,1,100,100,1);
é a variável que será 0-1023 para a faixa 0-255.
convertida; o segundo e o
terceiro parâmetros são os
valores mínimo e máximo
dessa variável; o quarto e o
quinto são os novos valores
mínimo e máximo da
variavel ‘valor’.

38
5. Exercícios

39
 5.1. Exercícios de compreensão

Nessa seção serão apresentados exercícios para a fixação do conteúdo apresentado

na apostila.

5.1.1. Instale a IDE do Arduino em seu computador. Ela está disponível para
download no site http://arduino.cc/
5.1.2. Crie um programa que faça com que um LED pisque, ficando 1 segundo
apagado e 2 segundos aceso
5.1.3. Crie um programa para ler o sensor IR
5.1.4. Crie um programa para ler o sensor ultrassônico
5.1.5. Crie um programa que faça com que o motor gire para ambos os lados,
depois acelere de desacelere até parar.
5.1.6. Crie um programa para o servomotor ir até 180°, depois até 90°, até 160° e
voltar a 0°.
5.1.7. Crie um programa para exibir a frase “Alo mundo!” no LCD.
5.1.8. Crie um programa que leia o valor do sensor IR e o exiba no LCD.

5.2. Seguidor de linha

Agora será apresentado um roteiro em formato de lista de exercício para a montagem

de um seguidor de linha.

5.2.1. Monte a estrutura do seguidor de linha com todos os seus componentes.

Esquemas de ligação dos componentes podem ser encontrados em anexo
no final do material.
5.2.2. Instale a IDE do Arduino em seu computador. Ela está disponível para
download no site http://arduino.cc/.
5.2.3. Crie uma função para que o robô siga a linha.
5.2.4. Crie uma função para que o robô desvie de obstáculos.
5.2.5. Crie uma função para que o robô identifique uma fita prateada.
5.2.6. Modifique a função do exercício 4.2.3 para que caso exista um gap
(interrupção da linha) ele continue em linha reta até reencontrar a linha.
5.2.7. Modifique a função do exercício 4.2.6 para que quando o robô atinja um
cruzamento ele sempre vire à direita.
5.2.8. Crie uma função para que o robô encontre uma latinha prateada em uma
sala sem linhas.
5.2.9. Crie uma função que feche a garra.
5.2.10. Crie uma função que abra a garra.

40
A. Esquemas de montagem de alguns componentes

Figura A.1 – Ligação do sensor LDR

41
 Figura A.2 – Ligação do LED

Figura A.3 – Ligação do módulo de motor

42
Figura A.4 – Ligação do servomotor

Figura A.5 – Ligação do sensor ultrassônico

43
 B. Informações adicionais

Este material foi baseado em diversos tutoriais encontrados nesses sites:

o http://www.meccomeletronica.com/site/data/uploads/apostila-de-arduino.pdf
o http://blog.filipeflop.com/arduino/o-que-e-arduino.html
o http://arduino.cc/
o http://blog.filipeflop.com/motores-e-servos/motor-dc-arduino-ponte-h-l298n.html
o http://pt.wikipedia.org/wiki/Servomotor
o http://en.wikipedia.org/wiki/Passive_infrared_sensor

Como leitura complementar, recomendamos:

o https://www.circuitar.com.br/
o http://arduino.cc/
o http://ordemnatural.com.br/pdf-files/CartilhadoArduino_ed1.pdf (Arduino -
Cartilha para programação em C)

44